vtcode-config 0.166.0

Config loader components shared across VT Code and downstream adopters
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use crate::loader::layers::ConfigLayerMetadata;
use hashbrown::HashMap;

/// Recursively merge two TOML values.
///
/// If both values are tables, they are merged recursively.
/// Otherwise, the `overlay` value replaces the `base` value.
pub fn merge_toml_values(base: &mut toml::Value, overlay: &toml::Value) {
    match (base, overlay) {
        (toml::Value::Table(base_table), toml::Value::Table(overlay_table)) => {
            for (key, value) in overlay_table {
                if let Some(base_value) = base_table.get_mut(key) {
                    merge_toml_values(base_value, value);
                } else {
                    base_table.insert(key.clone(), value.clone());
                }
            }
        }
        (base, overlay) => {
            *base = overlay.clone();
        }
    }
}

/// Recursively merge two TOML values and record which layer last wrote each path.
pub fn merge_toml_values_with_origins(
    base: &mut toml::Value,
    overlay: &toml::Value,
    origins: &mut HashMap<String, ConfigLayerMetadata>,
    layer: &ConfigLayerMetadata,
) {
    merge_with_origins(base, overlay, "", origins, layer);
}

fn merge_with_origins(
    base: &mut toml::Value,
    overlay: &toml::Value,
    path: &str,
    origins: &mut HashMap<String, ConfigLayerMetadata>,
    layer: &ConfigLayerMetadata,
) {
    match (base, overlay) {
        (toml::Value::Table(base_table), toml::Value::Table(overlay_table)) => {
            for (key, value) in overlay_table {
                let child_path = if path.is_empty() {
                    key.clone()
                } else {
                    format!("{path}.{key}")
                };

                if let Some(base_value) = base_table.get_mut(key) {
                    if base_value.is_table() && value.is_table() {
                        merge_with_origins(base_value, value, &child_path, origins, layer);
                    } else {
                        *base_value = value.clone();
                        assign_origins(value, &child_path, origins, layer);
                    }
                } else {
                    base_table.insert(key.clone(), value.clone());
                    assign_origins(value, &child_path, origins, layer);
                }
            }
        }
        (base, overlay) => {
            *base = overlay.clone();
            if !path.is_empty() {
                assign_origins(overlay, path, origins, layer);
            }
        }
    }
}

fn assign_origins(
    value: &toml::Value,
    path: &str,
    origins: &mut HashMap<String, ConfigLayerMetadata>,
    layer: &ConfigLayerMetadata,
) {
    match value {
        toml::Value::Table(table) => {
            for (key, child) in table {
                let child_path = if path.is_empty() {
                    key.clone()
                } else {
                    format!("{path}.{key}")
                };
                assign_origins(child, &child_path, origins, layer);
            }
        }
        _ => {
            origins.insert(path.to_string(), layer.clone());
        }
    }
}

/// Promote legacy top-level `default_provider` / `default_model` keys into the
/// canonical `[agent]` table within a single layer value.
///
/// Older global files (and hand-edited configs) use bare
/// `default_provider = "ollama"` / `default_model = "..."` at the document
/// root. `VTCodeConfig` only deserializes `agent.provider` /
/// `agent.default_model`, so without this promotion those keys are silently
/// dropped and the runtime falls back to the compiled-in default (openrouter).
/// The promotion is per-layer so normal layer precedence still applies: an
/// explicit `[agent] provider` in the same file wins over its own top-level
/// alias, and higher-precedence layers win over lower ones.
pub(crate) fn normalize_legacy_top_level_provider_aliases(value: &mut toml::Value) {
    let Some(table) = value.as_table_mut() else {
        return;
    };

    let legacy_provider = table
        .get("default_provider")
        .and_then(|v| v.as_str())
        .map(str::trim)
        .filter(|s| !s.is_empty())
        .map(ToOwned::to_owned);
    let legacy_model = table
        .get("default_model")
        .and_then(|v| v.as_str())
        .map(str::trim)
        .filter(|s| !s.is_empty())
        .map(ToOwned::to_owned);

    if legacy_provider.is_none() && legacy_model.is_none() {
        return;
    }

    let agent_entry = table
        .entry("agent".to_string())
        .or_insert(toml::Value::Table(toml::Table::new()));
    let Some(agent_table) = agent_entry.as_table_mut() else {
        return;
    };

    if let Some(provider) = legacy_provider
        && !agent_table.contains_key("provider")
    {
        agent_table.insert("provider".to_string(), toml::Value::String(provider));
    }
    if let Some(model) = legacy_model
        && !agent_table.contains_key("default_model")
    {
        agent_table.insert("default_model".to_string(), toml::Value::String(model));
    }
}