Skip to main content

cc_switch/config/
types.rs

1use serde::{Deserialize, Deserializer, Serialize, Serializer};
2use std::collections::BTreeMap;
3
4/// Type alias for configuration map
5type ConfigMap = BTreeMap<String, Configuration>;
6/// Type alias for environment variable map
7type EnvMap = BTreeMap<String, String>;
8/// Type alias for JSON value map
9type JsonMap = BTreeMap<String, serde_json::Value>;
10/// Type alias for Codex configuration map
11type CodexConfigMap = BTreeMap<String, crate::codex::CodexConfiguration>;
12/// Type alias for OMP configuration map
13type OmpConfigMap = BTreeMap<String, crate::omp::OmpConfiguration>;
14/// Type alias for grok configuration map
15type GrokConfigMap = BTreeMap<String, crate::grok::GrokConfiguration>;
16
17/// Storage mode for how configuration should be written to settings.json
18#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
19pub enum StorageMode {
20    /// Write to env field with uppercase environment variable names (default)
21    #[serde(rename = "env")]
22    #[default]
23    Env,
24    /// Write to root level with camelCase field names
25    #[serde(rename = "config")]
26    Config,
27}
28
29/// Represents a Claude API configuration
30///
31/// Contains the components needed to configure Claude API access:
32/// - alias_name: User-friendly identifier for the configuration
33/// - token: API authentication token
34/// - url: Base URL for the API endpoint
35/// - model: Optional custom model name
36/// - small_fast_model: Optional Haiku-class model for background tasks
37#[derive(Serialize, Deserialize, Default, Clone)]
38pub struct Configuration {
39    /// User-friendly alias name for this configuration
40    pub alias_name: String,
41    /// ANTHROPIC_AUTH_TOKEN value (API authentication token)
42    pub token: String,
43    /// ANTHROPIC_API_KEY value (alternative to AUTH_TOKEN, mutually exclusive)
44    #[serde(skip_serializing_if = "Option::is_none")]
45    pub api_key: Option<String>,
46    /// ANTHROPIC_BASE_URL value (API endpoint URL)
47    pub url: String,
48    /// ANTHROPIC_MODEL value (custom model name)
49    #[serde(skip_serializing_if = "Option::is_none")]
50    pub model: Option<String>,
51    /// ANTHROPIC_SMALL_FAST_MODEL value (Haiku-class model for background tasks)
52    #[serde(skip_serializing_if = "Option::is_none")]
53    pub small_fast_model: Option<String>,
54    /// ANTHROPIC_MAX_THINKING_TOKENS value (Maximum thinking tokens limit)
55    #[serde(skip_serializing_if = "Option::is_none")]
56    pub max_thinking_tokens: Option<u32>,
57    /// API timeout in milliseconds
58    #[serde(skip_serializing_if = "Option::is_none")]
59    pub api_timeout_ms: Option<u32>,
60    /// Disable non-essential traffic flag
61    #[serde(skip_serializing_if = "Option::is_none")]
62    pub claude_code_disable_nonessential_traffic: Option<u32>,
63    /// Default Sonnet model name
64    #[serde(skip_serializing_if = "Option::is_none")]
65    pub anthropic_default_sonnet_model: Option<String>,
66    /// Default Opus model name
67    #[serde(skip_serializing_if = "Option::is_none")]
68    pub anthropic_default_opus_model: Option<String>,
69    /// Default Haiku model name
70    #[serde(skip_serializing_if = "Option::is_none")]
71    pub anthropic_default_haiku_model: Option<String>,
72    /// Enable experimental agent teams flag
73    #[serde(skip_serializing_if = "Option::is_none")]
74    pub claude_code_experimental_agent_teams: Option<u32>,
75    /// Disable 1M context limit flag
76    #[serde(skip_serializing_if = "Option::is_none")]
77    pub claude_code_disable_1m_context: Option<u32>,
78    /// Subagent model name
79    #[serde(skip_serializing_if = "Option::is_none")]
80    pub claude_code_subagent_model: Option<String>,
81    /// Disable non-streaming fallback flag
82    #[serde(skip_serializing_if = "Option::is_none")]
83    pub claude_code_disable_nonstreaming_fallback: Option<u32>,
84    /// Effort level for Claude Code
85    #[serde(skip_serializing_if = "Option::is_none")]
86    pub claude_code_effort_level: Option<String>,
87    /// Auto compact window size for Claude Code
88    #[serde(skip_serializing_if = "Option::is_none")]
89    pub claude_code_auto_compact_window: Option<String>,
90    /// Disable prompt caching flag
91    #[serde(skip_serializing_if = "Option::is_none")]
92    pub disable_prompt_caching: Option<u32>,
93    /// Disable experimental betas flag
94    #[serde(skip_serializing_if = "Option::is_none")]
95    pub claude_code_disable_experimental_betas: Option<u32>,
96    /// Disable auto-updater flag
97    #[serde(skip_serializing_if = "Option::is_none")]
98    pub disable_autoupdater: Option<u32>,
99}
100
101impl Configuration {
102    /// Get all environment variable names that this configuration can set
103    ///
104    /// Returns a vector of all UPPERCASE environment variable names
105    /// that can be set by this configuration, used for conflict detection
106    /// in config mode.
107    pub fn get_env_field_names() -> Vec<&'static str> {
108        vec![
109            "ANTHROPIC_AUTH_TOKEN",
110            "ANTHROPIC_API_KEY",
111            "ANTHROPIC_BASE_URL",
112            "ANTHROPIC_MODEL",
113            "ANTHROPIC_SMALL_FAST_MODEL",
114            "ANTHROPIC_MAX_THINKING_TOKENS",
115            "API_TIMEOUT_MS",
116            "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC",
117            "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS",
118            "CLAUDE_CODE_DISABLE_1M_CONTEXT",
119            "CLAUDE_CODE_SUBAGENT_MODEL",
120            "CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK",
121            "CLAUDE_CODE_EFFORT_LEVEL",
122            "CLAUDE_CODE_AUTO_COMPACT_WINDOW",
123            "DISABLE_PROMPT_CACHING",
124            "CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS",
125            "DISABLE_AUTOUPDATER",
126            "ANTHROPIC_DEFAULT_SONNET_MODEL",
127            "ANTHROPIC_DEFAULT_OPUS_MODEL",
128            "ANTHROPIC_DEFAULT_HAIKU_MODEL",
129        ]
130    }
131
132    /// Get the authentication credential and its environment variable name.
133    ///
134    /// Returns `("ANTHROPIC_API_KEY", key)` when `api_key` is set,
135    /// otherwise `("ANTHROPIC_AUTH_TOKEN", token)`.
136    pub fn auth_env_pair(&self) -> (&'static str, &str) {
137        if let Some(ref key) = self.api_key {
138            ("ANTHROPIC_API_KEY", key)
139        } else {
140            ("ANTHROPIC_AUTH_TOKEN", &self.token)
141        }
142    }
143
144    /// Get environment variable names that should be cleared in env mode
145    ///
146    /// Returns a vector of UPPERCASE environment variable names that are
147    /// configuration-specific and should be cleared from settings.json when
148    /// switching in env mode. User preference fields are excluded.
149    pub fn get_clearable_env_field_names() -> Vec<&'static str> {
150        vec![
151            "ANTHROPIC_AUTH_TOKEN",
152            "ANTHROPIC_API_KEY",
153            "ANTHROPIC_BASE_URL",
154            "ANTHROPIC_MODEL",
155            "ANTHROPIC_SMALL_FAST_MODEL",
156            "ANTHROPIC_MAX_THINKING_TOKENS",
157            "API_TIMEOUT_MS",
158            "ANTHROPIC_DEFAULT_SONNET_MODEL",
159            "ANTHROPIC_DEFAULT_OPUS_MODEL",
160            "ANTHROPIC_DEFAULT_HAIKU_MODEL",
161            "CLAUDE_CODE_SUBAGENT_MODEL",
162            "CLAUDE_CODE_EFFORT_LEVEL",
163            "CLAUDE_CODE_AUTO_COMPACT_WINDOW",
164            // User preference fields are NOT included:
165            // - CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC
166            // - CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS
167            // - CLAUDE_CODE_DISABLE_1M_CONTEXT
168            // - CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK
169            // - DISABLE_PROMPT_CACHING
170            // - CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS
171            // - DISABLE_AUTOUPDATER
172        ]
173    }
174}
175
176#[cfg(test)]
177mod tests {
178    use super::*;
179
180    #[test]
181    fn test_get_env_field_names() {
182        let fields = Configuration::get_env_field_names();
183
184        // Verify all expected fields are present
185        let expected_fields = vec![
186            "ANTHROPIC_AUTH_TOKEN",
187            "ANTHROPIC_API_KEY",
188            "ANTHROPIC_BASE_URL",
189            "ANTHROPIC_MODEL",
190            "ANTHROPIC_SMALL_FAST_MODEL",
191            "ANTHROPIC_MAX_THINKING_TOKENS",
192            "API_TIMEOUT_MS",
193            "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC",
194            "ANTHROPIC_DEFAULT_SONNET_MODEL",
195            "ANTHROPIC_DEFAULT_OPUS_MODEL",
196            "ANTHROPIC_DEFAULT_HAIKU_MODEL",
197            "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS",
198            "CLAUDE_CODE_DISABLE_1M_CONTEXT",
199            "CLAUDE_CODE_SUBAGENT_MODEL",
200            "CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK",
201            "CLAUDE_CODE_EFFORT_LEVEL",
202            "CLAUDE_CODE_AUTO_COMPACT_WINDOW",
203            "DISABLE_PROMPT_CACHING",
204            "CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS",
205            "DISABLE_AUTOUPDATER",
206        ];
207
208        assert_eq!(
209            fields.len(),
210            expected_fields.len(),
211            "Should have exactly 20 fields"
212        );
213
214        for expected_field in expected_fields {
215            assert!(
216                fields.contains(&expected_field),
217                "Missing field: {}",
218                expected_field
219            );
220        }
221
222        // Verify all fields are uppercase
223        for field in &fields {
224            assert_eq!(
225                field,
226                &field.to_uppercase(),
227                "Field {} should be uppercase",
228                field
229            );
230        }
231    }
232
233    #[test]
234    fn test_get_clearable_env_field_names() {
235        let fields = Configuration::get_clearable_env_field_names();
236
237        // Verify clearable fields (excludes user preference fields)
238        let expected_fields = vec![
239            "ANTHROPIC_AUTH_TOKEN",
240            "ANTHROPIC_API_KEY",
241            "ANTHROPIC_BASE_URL",
242            "ANTHROPIC_MODEL",
243            "ANTHROPIC_SMALL_FAST_MODEL",
244            "ANTHROPIC_MAX_THINKING_TOKENS",
245            "API_TIMEOUT_MS",
246            "ANTHROPIC_DEFAULT_SONNET_MODEL",
247            "ANTHROPIC_DEFAULT_OPUS_MODEL",
248            "ANTHROPIC_DEFAULT_HAIKU_MODEL",
249            "CLAUDE_CODE_SUBAGENT_MODEL",
250            "CLAUDE_CODE_EFFORT_LEVEL",
251            "CLAUDE_CODE_AUTO_COMPACT_WINDOW",
252        ];
253
254        // User preference fields should NOT be in clearable list
255        let excluded_fields = vec![
256            "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC",
257            "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS",
258            "CLAUDE_CODE_DISABLE_1M_CONTEXT",
259            "CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK",
260            "DISABLE_PROMPT_CACHING",
261            "CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS",
262            "DISABLE_AUTOUPDATER",
263        ];
264
265        assert_eq!(
266            fields.len(),
267            expected_fields.len(),
268            "Should have exactly 13 clearable fields"
269        );
270
271        for expected_field in expected_fields {
272            assert!(
273                fields.contains(&expected_field),
274                "Missing clearable field: {}",
275                expected_field
276            );
277        }
278
279        // Verify excluded fields are NOT present
280        for excluded_field in excluded_fields {
281            assert!(
282                !fields.contains(&excluded_field),
283                "User preference field {} should NOT be in clearable list",
284                excluded_field
285            );
286        }
287    }
288
289    #[test]
290    fn test_remove_anthropic_env_uses_dynamic_fields() {
291        let mut settings = ClaudeSettings::default();
292
293        // Add all possible environment variables
294        let env_fields = Configuration::get_env_field_names();
295        for field in &env_fields {
296            settings
297                .env
298                .insert(field.to_string(), "test_value".to_string());
299        }
300
301        // Add some other env variables that shouldn't be removed
302        settings
303            .env
304            .insert("OTHER_VAR".to_string(), "other_value".to_string());
305        settings
306            .env
307            .insert("CLAUDE_THEME".to_string(), "dark".to_string());
308
309        // Remove Anthropic environment variables
310        settings.remove_anthropic_env();
311
312        // Verify all Anthropic fields are removed
313        for field in &env_fields {
314            assert!(
315                !settings.env.contains_key(*field),
316                "Field {} should be removed",
317                field
318            );
319        }
320
321        // Verify other fields are preserved
322        assert!(
323            settings.env.contains_key("OTHER_VAR"),
324            "Other variables should be preserved"
325        );
326        assert!(
327            settings.env.contains_key("CLAUDE_THEME"),
328            "Other variables should be preserved"
329        );
330        assert_eq!(
331            settings.env.get("OTHER_VAR"),
332            Some(&"other_value".to_string())
333        );
334        assert_eq!(settings.env.get("CLAUDE_THEME"), Some(&"dark".to_string()));
335    }
336
337    #[test]
338    fn test_switch_to_config_uses_dynamic_fields() {
339        let mut settings = ClaudeSettings::default();
340
341        // Add all possible environment variables
342        let env_fields = Configuration::get_env_field_names();
343        for field in &env_fields {
344            settings
345                .env
346                .insert(field.to_string(), "old_value".to_string());
347        }
348
349        // Create a test configuration
350        let config = Configuration {
351            alias_name: "test".to_string(),
352            token: "new_token".to_string(),
353            api_key: None,
354            url: "https://api.new.com".to_string(),
355            model: Some("new_model".to_string()),
356            small_fast_model: Some("new_fast_model".to_string()),
357            max_thinking_tokens: Some(50000),
358            api_timeout_ms: Some(300000),
359            claude_code_disable_nonessential_traffic: Some(1),
360            anthropic_default_sonnet_model: Some("new_sonnet".to_string()),
361            anthropic_default_opus_model: Some("new_opus".to_string()),
362            anthropic_default_haiku_model: Some("new_haiku".to_string()),
363            claude_code_experimental_agent_teams: None,
364            claude_code_disable_1m_context: None,
365            claude_code_subagent_model: None,
366            claude_code_disable_nonstreaming_fallback: None,
367            claude_code_effort_level: None,
368            claude_code_auto_compact_window: None,
369            disable_prompt_caching: None,
370            claude_code_disable_experimental_betas: None,
371            disable_autoupdater: None,
372        };
373
374        // Switch to new configuration
375        settings.switch_to_config(&config);
376
377        // Verify the required fields are set correctly
378        assert_eq!(
379            settings.env.get("ANTHROPIC_AUTH_TOKEN"),
380            Some(&"new_token".to_string())
381        );
382        assert_eq!(
383            settings.env.get("ANTHROPIC_BASE_URL"),
384            Some(&"https://api.new.com".to_string())
385        );
386        assert_eq!(
387            settings.env.get("ANTHROPIC_MODEL"),
388            Some(&"new_model".to_string())
389        );
390        assert_eq!(
391            settings.env.get("ANTHROPIC_SMALL_FAST_MODEL"),
392            Some(&"new_fast_model".to_string())
393        );
394
395        // Verify additional fields are set correctly when provided in config
396        assert_eq!(
397            settings.env.get("ANTHROPIC_MAX_THINKING_TOKENS"),
398            Some(&"50000".to_string())
399        );
400        assert_eq!(
401            settings.env.get("API_TIMEOUT_MS"),
402            Some(&"300000".to_string())
403        );
404        assert_eq!(
405            settings.env.get("CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC"),
406            Some(&"1".to_string())
407        );
408        assert_eq!(
409            settings.env.get("ANTHROPIC_DEFAULT_SONNET_MODEL"),
410            Some(&"new_sonnet".to_string())
411        );
412        assert_eq!(
413            settings.env.get("ANTHROPIC_DEFAULT_OPUS_MODEL"),
414            Some(&"new_opus".to_string())
415        );
416        assert_eq!(
417            settings.env.get("ANTHROPIC_DEFAULT_HAIKU_MODEL"),
418            Some(&"new_haiku".to_string())
419        );
420    }
421
422    #[test]
423    fn test_switch_to_config_removes_optional_fields_when_not_provided() {
424        let mut settings = ClaudeSettings::default();
425
426        // Add all possible environment variables with old values
427        let env_fields = Configuration::get_env_field_names();
428        for field in &env_fields {
429            settings
430                .env
431                .insert(field.to_string(), "old_value".to_string());
432        }
433
434        // Create a test configuration without optional fields
435        let config = Configuration {
436            alias_name: "test".to_string(),
437            token: "new_token".to_string(),
438            api_key: None,
439            url: "https://api.new.com".to_string(),
440            model: Some("new_model".to_string()),
441            small_fast_model: Some("new_fast_model".to_string()),
442            max_thinking_tokens: None,
443            api_timeout_ms: None,
444            claude_code_disable_nonessential_traffic: None,
445            anthropic_default_sonnet_model: None,
446            anthropic_default_opus_model: None,
447            anthropic_default_haiku_model: None,
448            claude_code_experimental_agent_teams: None,
449            claude_code_disable_1m_context: None,
450            claude_code_subagent_model: None,
451            claude_code_disable_nonstreaming_fallback: None,
452            claude_code_effort_level: None,
453            claude_code_auto_compact_window: None,
454            disable_prompt_caching: None,
455            claude_code_disable_experimental_betas: None,
456            disable_autoupdater: None,
457        };
458
459        // Switch to new configuration
460        settings.switch_to_config(&config);
461
462        // Verify the required fields are set correctly
463        assert_eq!(
464            settings.env.get("ANTHROPIC_AUTH_TOKEN"),
465            Some(&"new_token".to_string())
466        );
467        assert_eq!(
468            settings.env.get("ANTHROPIC_BASE_URL"),
469            Some(&"https://api.new.com".to_string())
470        );
471        assert_eq!(
472            settings.env.get("ANTHROPIC_MODEL"),
473            Some(&"new_model".to_string())
474        );
475        assert_eq!(
476            settings.env.get("ANTHROPIC_SMALL_FAST_MODEL"),
477            Some(&"new_fast_model".to_string())
478        );
479
480        // Verify optional fields are removed when not provided in config
481        assert!(!settings.env.contains_key("ANTHROPIC_MAX_THINKING_TOKENS"));
482        assert!(!settings.env.contains_key("API_TIMEOUT_MS"));
483        assert!(
484            !settings
485                .env
486                .contains_key("CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC")
487        );
488        assert!(!settings.env.contains_key("ANTHROPIC_DEFAULT_SONNET_MODEL"));
489        assert!(!settings.env.contains_key("ANTHROPIC_DEFAULT_OPUS_MODEL"));
490        assert!(!settings.env.contains_key("ANTHROPIC_DEFAULT_HAIKU_MODEL"));
491        assert!(!settings.env.contains_key("CLAUDE_CODE_SUBAGENT_MODEL"));
492        assert!(
493            !settings
494                .env
495                .contains_key("CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK")
496        );
497        assert!(!settings.env.contains_key("CLAUDE_CODE_EFFORT_LEVEL"));
498        assert!(!settings.env.contains_key("DISABLE_PROMPT_CACHING"));
499        assert!(
500            !settings
501                .env
502                .contains_key("CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS")
503        );
504        assert!(!settings.env.contains_key("DISABLE_AUTOUPDATER"));
505    }
506}
507
508/// Storage manager for Claude API configurations
509///
510/// Handles persistence and retrieval of multiple API configurations
511/// stored in `~/.cc_auto_switch/configurations.json`
512#[derive(Serialize, Deserialize, Default)]
513pub struct ConfigStorage {
514    /// Map of alias names to configuration objects
515    pub configurations: ConfigMap,
516    /// Custom directory for Claude settings (optional)
517    pub claude_settings_dir: Option<String>,
518    /// Default storage mode for writing configurations (None = use env mode)
519    #[serde(skip_serializing_if = "Option::is_none")]
520    pub default_storage_mode: Option<StorageMode>,
521    /// Codex (OpenAI) configurations, stored separately from Claude configurations
522    #[serde(skip_serializing_if = "Option::is_none")]
523    pub codex_configurations: Option<CodexConfigMap>,
524    /// OMP configurations, stored separately from Claude configurations
525    #[serde(skip_serializing_if = "Option::is_none")]
526    pub omp_configurations: Option<OmpConfigMap>,
527    /// grok configurations, stored separately from Claude configurations
528    #[serde(skip_serializing_if = "Option::is_none")]
529    pub grok_configurations: Option<GrokConfigMap>,
530}
531
532/// Claude settings manager for API configuration
533///
534/// Manages the Claude settings.json file to control Claude's API configuration
535/// Handles environment variables and preserves other settings
536#[derive(Default, Clone)]
537#[allow(dead_code)]
538pub struct ClaudeSettings {
539    /// Environment variables map (ANTHROPIC_AUTH_TOKEN, ANTHROPIC_BASE_URL, ANTHROPIC_MODEL, ANTHROPIC_SMALL_FAST_MODEL)
540    pub env: EnvMap,
541    /// Other settings to preserve when modifying API configuration
542    pub other: JsonMap,
543}
544
545impl Serialize for ClaudeSettings {
546    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
547    where
548        S: Serializer,
549    {
550        use serde::ser::SerializeMap;
551
552        let mut map = serializer.serialize_map(Some(
553            self.other.len() + if self.env.is_empty() { 0 } else { 1 },
554        ))?;
555
556        // Serialize env field only if it has content
557        if !self.env.is_empty() {
558            map.serialize_entry("env", &self.env)?;
559        }
560
561        // Serialize other fields
562        for (key, value) in &self.other {
563            map.serialize_entry(key, value)?;
564        }
565
566        map.end()
567    }
568}
569
570impl<'de> Deserialize<'de> for ClaudeSettings {
571    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
572    where
573        D: Deserializer<'de>,
574    {
575        #[derive(Deserialize)]
576        struct ClaudeSettingsHelper {
577            #[serde(default)]
578            env: EnvMap,
579            #[serde(flatten)]
580            other: JsonMap,
581        }
582
583        let helper = ClaudeSettingsHelper::deserialize(deserializer)?;
584        Ok(ClaudeSettings {
585            env: helper.env,
586            other: helper.other,
587        })
588    }
589}
590
591/// Parameters for adding a new configuration
592#[allow(dead_code)]
593pub struct AddCommandParams {
594    pub alias_name: String,
595    pub token: Option<String>,
596    pub api_key: Option<String>,
597    pub url: Option<String>,
598    pub model: Option<String>,
599    pub small_fast_model: Option<String>,
600    pub max_thinking_tokens: Option<u32>,
601    pub api_timeout_ms: Option<u32>,
602    pub claude_code_disable_nonessential_traffic: Option<u32>,
603    pub anthropic_default_sonnet_model: Option<String>,
604    pub anthropic_default_opus_model: Option<String>,
605    pub anthropic_default_haiku_model: Option<String>,
606    pub claude_code_subagent_model: Option<String>,
607    pub claude_code_disable_nonstreaming_fallback: Option<u32>,
608    pub claude_code_effort_level: Option<String>,
609    pub claude_code_auto_compact_window: Option<String>,
610    pub disable_prompt_caching: Option<u32>,
611    pub claude_code_disable_experimental_betas: Option<u32>,
612    pub disable_autoupdater: Option<u32>,
613    pub force: bool,
614    pub interactive: bool,
615    pub token_arg: Option<String>,
616    pub url_arg: Option<String>,
617    pub from_file: Option<String>,
618    pub from_json: Option<String>,
619    pub from_stdin: bool,
620}