d60f350cf8
This PR introduces support for `-c`/`--config` so users can override individual config values on the command line using `--config name=value`. Example: ``` codex --config model=o4-mini ``` Making it possible to set arbitrary config values on the command line results in a more flexible configuration scheme and makes it easier to provide single-line examples that can be copy-pasted from documentation. Effectively, it means there are four levels of configuration for some values: - Default value (e.g., `model` currently defaults to `o4-mini`) - Value in `config.toml` (e.g., user could override the default to be `model = "o3"` in their `config.toml`) - Specifying `-c` or `--config` to override `model` (e.g., user can include `-c model=o3` in their list of args to Codex) - If available, a config-specific flag can be used, which takes precedence over `-c` (e.g., user can specify `--model o3` in their list of args to Codex) Now that it is possible to specify anything that could be configured in `config.toml` on the command line using `-c`, we do not need to have a custom flag for every possible config option (which can clutter the output of `--help`). To that end, as part of this PR, we drop support for the `--disable-response-storage` flag, as users can now specify `-c disable_response_storage=true` to get the equivalent functionality. Under the hood, this works by loading the `config.toml` into a `toml::Value`. Then for each `key=value`, we create a small synthetic TOML file with `value` so that we can run the TOML parser to get the equivalent `toml::Value`. We then parse `key` to determine the point in the original `toml::Value` to do the insert/replace. Once all of the overrides from `-c` args have been applied, the `toml::Value` is deserialized into a `ConfigToml` and then the `ConfigOverrides` are applied, as before.
85 lines
2.5 KiB
Rust
85 lines
2.5 KiB
Rust
use serde_json::Value as JsonValue;
|
|
use toml::Value as TomlValue;
|
|
|
|
/// Convert a `serde_json::Value` into a semantically equivalent `toml::Value`.
|
|
pub(crate) fn json_to_toml(v: JsonValue) -> TomlValue {
|
|
match v {
|
|
JsonValue::Null => TomlValue::String(String::new()),
|
|
JsonValue::Bool(b) => TomlValue::Boolean(b),
|
|
JsonValue::Number(n) => {
|
|
if let Some(i) = n.as_i64() {
|
|
TomlValue::Integer(i)
|
|
} else if let Some(f) = n.as_f64() {
|
|
TomlValue::Float(f)
|
|
} else {
|
|
TomlValue::String(n.to_string())
|
|
}
|
|
}
|
|
JsonValue::String(s) => TomlValue::String(s),
|
|
JsonValue::Array(arr) => TomlValue::Array(arr.into_iter().map(json_to_toml).collect()),
|
|
JsonValue::Object(map) => {
|
|
let tbl = map
|
|
.into_iter()
|
|
.map(|(k, v)| (k, json_to_toml(v)))
|
|
.collect::<toml::value::Table>();
|
|
TomlValue::Table(tbl)
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
#[allow(clippy::unwrap_used)]
|
|
mod tests {
|
|
use super::*;
|
|
use pretty_assertions::assert_eq;
|
|
use serde_json::json;
|
|
|
|
#[test]
|
|
fn json_number_to_toml() {
|
|
let json_value = json!(123);
|
|
assert_eq!(TomlValue::Integer(123), json_to_toml(json_value));
|
|
}
|
|
|
|
#[test]
|
|
fn json_array_to_toml() {
|
|
let json_value = json!([true, 1]);
|
|
assert_eq!(
|
|
TomlValue::Array(vec![TomlValue::Boolean(true), TomlValue::Integer(1)]),
|
|
json_to_toml(json_value)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn json_bool_to_toml() {
|
|
let json_value = json!(false);
|
|
assert_eq!(TomlValue::Boolean(false), json_to_toml(json_value));
|
|
}
|
|
|
|
#[test]
|
|
fn json_float_to_toml() {
|
|
let json_value = json!(1.25);
|
|
assert_eq!(TomlValue::Float(1.25), json_to_toml(json_value));
|
|
}
|
|
|
|
#[test]
|
|
fn json_null_to_toml() {
|
|
let json_value = serde_json::Value::Null;
|
|
assert_eq!(TomlValue::String(String::new()), json_to_toml(json_value));
|
|
}
|
|
|
|
#[test]
|
|
fn json_object_nested() {
|
|
let json_value = json!({ "outer": { "inner": 2 } });
|
|
let expected = {
|
|
let mut inner = toml::value::Table::new();
|
|
inner.insert("inner".into(), TomlValue::Integer(2));
|
|
|
|
let mut outer = toml::value::Table::new();
|
|
outer.insert("outer".into(), TomlValue::Table(inner));
|
|
TomlValue::Table(outer)
|
|
};
|
|
|
|
assert_eq!(json_to_toml(json_value), expected);
|
|
}
|
|
}
|