From e3de9544867aeefa23da51b457a140d715506e39 Mon Sep 17 00:00:00 2001 From: Ahmed Ibrahim Date: Thu, 7 May 2026 01:16:54 +0300 Subject: [PATCH] Use default-on-error config enum warnings --- codex-rs/Cargo.lock | 1 + codex-rs/config/Cargo.toml | 1 + codex-rs/config/src/config_toml.rs | 70 ++- codex-rs/config/src/lenient.rs | 565 +++++++++--------- codex-rs/config/src/loader/mod.rs | 2 +- codex-rs/config/src/mcp_types.rs | 6 + codex-rs/config/src/profile_toml.rs | 25 + codex-rs/config/src/state.rs | 12 +- codex-rs/config/src/types.rs | 25 + codex-rs/core/config.schema.json | 136 ++++- .../core/src/config/config_loader_tests.rs | 10 +- codex-rs/core/src/config/mod.rs | 10 +- 12 files changed, 540 insertions(+), 323 deletions(-) diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lock index 6359089371..08f4de6342 100644 --- a/codex-rs/Cargo.lock +++ b/codex-rs/Cargo.lock @@ -2391,6 +2391,7 @@ dependencies = [ "serde", "serde_json", "serde_path_to_error", + "serde_with", "sha2", "tempfile", "thiserror 2.0.18", diff --git a/codex-rs/config/Cargo.toml b/codex-rs/config/Cargo.toml index 8cef4070c9..9e70c91a14 100644 --- a/codex-rs/config/Cargo.toml +++ b/codex-rs/config/Cargo.toml @@ -34,6 +34,7 @@ schemars = { workspace = true } serde = { workspace = true, features = ["derive"] } serde_json = { workspace = true } serde_path_to_error = { workspace = true } +serde_with = { workspace = true, features = ["macros"] } sha2 = { workspace = true } thiserror = { workspace = true } tokio = { workspace = true, features = ["fs"] } diff --git a/codex-rs/config/src/config_toml.rs b/codex-rs/config/src/config_toml.rs index 89eb30b798..0490a2f226 100644 --- a/codex-rs/config/src/config_toml.rs +++ b/codex-rs/config/src/config_toml.rs @@ -44,6 +44,7 @@ use codex_protocol::config_types::SandboxMode; use codex_protocol::config_types::ServiceTier; use codex_protocol::config_types::TrustLevel; use codex_protocol::config_types::Verbosity; +use codex_protocol::config_types::WebSearchContextSize; use codex_protocol::config_types::WebSearchMode; use codex_protocol::config_types::WebSearchToolConfig; use codex_protocol::config_types::WindowsSandboxLevel; @@ -57,6 +58,10 @@ use schemars::JsonSchema; use serde::Deserialize; use serde::Deserializer; use serde::Serialize; +use serde::de::Error as SerdeError; +use serde_with::DefaultOnError; +use serde_with::serde_as; +use toml::Value as TomlValue; const RESERVED_MODEL_PROVIDER_IDS: [&str; 4] = [ AMAZON_BEDROCK_PROVIDER_ID, @@ -88,6 +93,7 @@ const fn default_hide_agent_reasoning() -> Option { } /// Base config deserialized from ~/.codex/config.toml. +#[serde_as] #[derive(Serialize, Deserialize, Debug, Clone, Default, PartialEq, JsonSchema)] #[schemars(deny_unknown_fields)] pub struct ConfigToml { @@ -106,11 +112,15 @@ pub struct ConfigToml { pub model_auto_compact_token_limit: Option, /// Default approval policy for executing commands. + #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub approval_policy: Option, /// Configures who approval requests are routed to for review once they have /// been escalated. This does not disable separate safety checks such as /// ARC. + #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub approvals_reviewer: Option, /// Optional policy instructions for the guardian auto-reviewer. @@ -132,6 +142,8 @@ pub struct ConfigToml { pub allow_login_shell: Option, /// Sandbox mode to use. + #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub sandbox_mode: Option, /// Sandbox configuration to apply if `sandbox` is `WorkspaceWrite`. @@ -186,6 +198,7 @@ pub struct ConfigToml { /// When set, restricts the login mechanism users may use. #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub forced_login_method: Option, /// Preferred backend for storing CLI auth credentials. @@ -193,6 +206,7 @@ pub struct ConfigToml { /// keyring: Use an OS-specific keyring service. /// auto: Use the keyring if available, otherwise use a file. #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub cli_auth_credentials_store: Option, /// Definition for MCP servers that Codex can reach out to for tool calls. @@ -207,6 +221,7 @@ pub struct ConfigToml { /// file: Use a file in the Codex home directory. /// auto (default): Use the OS-specific keyring service if available, otherwise use a file. #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub mcp_oauth_credentials_store: Option, /// Optional fixed port for the local HTTP callback server used during MCP OAuth login. @@ -274,6 +289,8 @@ pub struct ConfigToml { /// Optional URI-based file opener. If set, citations to files in the model /// output will be hyperlinked using the specified URI scheme. + #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub file_opener: Option, /// Collection of settings that are specific to the TUI. @@ -288,10 +305,18 @@ pub struct ConfigToml { /// Defaults to `false`. pub show_raw_agent_reasoning: Option, + #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub model_reasoning_effort: Option, + #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub plan_mode_reasoning_effort: Option, + #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub model_reasoning_summary: Option, /// Optional verbosity control for GPT-5 models (Responses API `text.verbosity`). + #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub model_verbosity: Option, /// Override to force-enable reasoning summaries for the configured model. @@ -302,9 +327,13 @@ pub struct ConfigToml { pub model_catalog_json: Option, /// Optionally specify a personality for the model + #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub personality: Option, /// Optional explicit service tier preference for new turns (`fast` or `flex`). + #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub service_tier: Option, /// Base URL for requests to ChatGPT (as opposed to the OpenAI API). @@ -351,10 +380,14 @@ pub struct ConfigToml { pub experimental_thread_config_endpoint: Option, /// Experimental / do not use. Selects the thread store implementation. + #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub experimental_thread_store: Option, pub projects: Option>, /// Controls the web search tool mode: disabled, cached, or live. + #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub web_search: Option, /// Nested tools section for feature toggles @@ -577,13 +610,22 @@ pub struct RealtimeConfig { pub voice: Option, } +#[serde_as] #[derive(Serialize, Deserialize, Debug, Clone, Default, PartialEq, Eq, JsonSchema)] #[schemars(deny_unknown_fields)] pub struct RealtimeToml { + #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub version: Option, #[serde(rename = "type")] + #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub session_type: Option, + #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub transport: Option, + #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub voice: Option, } @@ -621,15 +663,35 @@ fn deserialize_optional_web_search_tool_config<'de, D>( where D: Deserializer<'de>, { - let value = Option::::deserialize(deserializer)?; + let Some(value) = Option::::deserialize(deserializer)? else { + return Ok(None); + }; + + let value = match value.clone().try_into::() { + Ok(value) => value, + Err(err) => { + let mut without_context_size = value.clone(); + let removed_context_size = without_context_size + .as_table_mut() + .and_then(|table| table.remove("context_size")) + .is_some_and(|context_size| { + context_size.try_into::().is_err() + }); + if !removed_context_size { + return Err(SerdeError::custom(err.to_string())); + } + without_context_size + .try_into::() + .map_err(SerdeError::custom)? + } + }; Ok(match value { - None => None, - Some(WebSearchToolConfigInput::Enabled(enabled)) => { + WebSearchToolConfigInput::Enabled(enabled) => { let _ = enabled; None } - Some(WebSearchToolConfigInput::Config(config)) => Some(config), + WebSearchToolConfigInput::Config(config) => Some(config), }) } diff --git a/codex-rs/config/src/lenient.rs b/codex-rs/config/src/lenient.rs index 4c8c719474..5cc096f709 100644 --- a/codex-rs/config/src/lenient.rs +++ b/codex-rs/config/src/lenient.rs @@ -1,318 +1,317 @@ +use crate::config_toml::ConfigToml; +use crate::config_toml::RealtimeTransport; +use crate::config_toml::RealtimeVoice; +use crate::config_toml::RealtimeWsMode; +use crate::config_toml::RealtimeWsVersion; +use crate::config_toml::ThreadStoreToml; +use crate::mcp_types::AppToolApproval; +use crate::types::AltScreenMode; +use crate::types::ApprovalsReviewer; +use crate::types::AuthCredentialsStoreMode; +use crate::types::HistoryPersistence; +use crate::types::MarketplaceSourceType; +use crate::types::NotificationCondition; +use crate::types::NotificationMethod; use crate::types::Notifications; +use crate::types::OAuthCredentialsStoreMode; +use crate::types::SessionPickerViewMode; +use crate::types::UriBasedFileOpener; +use crate::types::WindowsSandboxModeToml; +use codex_protocol::config_types::ForcedLoginMethod; +use codex_protocol::config_types::Personality; +use codex_protocol::config_types::ReasoningSummary; +use codex_protocol::config_types::SandboxMode; +use codex_protocol::config_types::ServiceTier; +use codex_protocol::config_types::ShellEnvironmentPolicyInherit; +use codex_protocol::config_types::Verbosity; use codex_protocol::config_types::WebSearchContextSize; +use codex_protocol::config_types::WebSearchMode; +use codex_protocol::openai_models::ReasoningEffort; +use codex_protocol::protocol::AskForApproval; use serde::de::DeserializeOwned; -use serde_path_to_error::Path as SerdePath; -use serde_path_to_error::Segment as SerdeSegment; use toml::Value as TomlValue; -const WEB_SEARCH_TOOL_CONFIG_INPUT_ERROR: &str = - "data did not match any variant of untagged enum WebSearchToolConfigInput"; -const NOTIFICATIONS_ERROR: &str = "data did not match any variant of untagged enum Notifications"; -const CONTEXT_SIZE_KEY: &str = "context_size"; -const NOTIFICATIONS_KEY: &str = "notifications"; +const SHELL_ENVIRONMENT_POLICY: &str = "shell_environment_policy"; +const CONTEXT_SIZE: &str = "context_size"; +const DEFAULT_TOOLS_APPROVAL_MODE: &str = "default_tools_approval_mode"; +const APPROVAL_MODE: &str = "approval_mode"; -/// Deserializes TOML while turning invalid enum-valued settings into warnings. +macro_rules! check_fields { + ($value:expr, $path:expr, $warnings:expr, $( $key:expr => $ty:ty ),+ $(,)?) => { + $( + check_value::<$ty>($value, &child_path($path, $key), $warnings); + )+ + }; +} + +/// Deserializes config while turning known invalid enum-valued settings into warnings. /// -/// Serde reports enum failures as normal deserialization errors, which would -/// otherwise reject the whole assembled config. Config files are user-editable, -/// so this helper keeps the strongly typed destination type and handles enum -/// leniency at the load boundary: deserialize, find the first invalid enum -/// value, remove only that TOML key, record a startup warning, and retry. -pub(crate) fn deserialize_with_enum_warnings( - mut value: TomlValue, -) -> Result<(TomlValue, T, Vec), toml::de::Error> -where - T: DeserializeOwned, -{ +/// The config structs use `serde_with::DefaultOnError` on their enum fields so +/// an invalid field can default instead of rejecting the whole file. This helper +/// runs the companion best-effort scan over the raw TOML first. When a known +/// enum-bearing leaf fails to parse as its real type, the leaf is removed from +/// the sanitized TOML and a startup warning is recorded. +pub(crate) fn deserialize_with_enum_warnings( + value: TomlValue, +) -> Result<(TomlValue, ConfigToml, Vec), toml::de::Error> { + let mut sanitized = value; + let warnings = remove_invalid_enum_values(&mut sanitized); + let parsed = sanitized.clone().try_into::()?; + Ok((sanitized, parsed, warnings)) +} + +fn remove_invalid_enum_values(value: &mut TomlValue) -> Vec { let mut warnings = Vec::new(); - - loop { - // serde_path_to_error gives us the config path that failed, so we can - // remove the offending TOML value without making invalid enum state - // representable inside ConfigToml or its nested structs. - match serde_path_to_error::deserialize(value.clone()) { - Ok(parsed) => return Ok((value, parsed, warnings)), - Err(err) => { - let Some(path) = path_segments(err.path()) else { - return Err(err.into_inner()); - }; - let toml_error = err.into_inner(); - - let removed = if is_unknown_variant_error(&toml_error) { - remove_unknown_variant_value::( - &mut value, - &path, - unknown_variant(&toml_error), - toml_error.message(), - ) - } else if is_web_search_tool_config_input_error(&toml_error) { - remove_invalid_web_search_context_size(&mut value, &path) - } else if is_notifications_error(&toml_error) { - remove_invalid_notifications_value(&mut value, &path) - } else { - None - }; - - let Some((removed_path, invalid_value)) = removed else { - return Err(toml_error); - }; - warnings.push(format!( - "Ignoring invalid config value at {}: {invalid_value}", - display_path(&removed_path) - )); - } - } - } + let path = Vec::new(); + scan_config_toml(value, &path, &mut warnings); + warnings } -#[derive(Clone, Debug, PartialEq, Eq)] -enum PathSegment { - Key(String), - Index(usize), +fn scan_config_toml(value: &mut TomlValue, path: &[String], warnings: &mut Vec) { + check_fields!( + value, + path, + warnings, + "approval_policy" => AskForApproval, + "approvals_reviewer" => ApprovalsReviewer, + "sandbox_mode" => SandboxMode, + "forced_login_method" => ForcedLoginMethod, + "cli_auth_credentials_store" => AuthCredentialsStoreMode, + "mcp_oauth_credentials_store" => OAuthCredentialsStoreMode, + "file_opener" => UriBasedFileOpener, + "model_reasoning_effort" => ReasoningEffort, + "plan_mode_reasoning_effort" => ReasoningEffort, + "model_reasoning_summary" => ReasoningSummary, + "model_verbosity" => Verbosity, + "personality" => Personality, + "service_tier" => ServiceTier, + "experimental_thread_store" => ThreadStoreToml, + "web_search" => WebSearchMode, + ); + + scan_shell_environment_policy(value, &child_path(path, SHELL_ENVIRONMENT_POLICY), warnings); + scan_history(value, &child_path(path, "history"), warnings); + scan_tui(value, &child_path(path, "tui"), warnings); + scan_realtime(value, &child_path(path, "realtime"), warnings); + scan_tools(value, &child_path(path, "tools"), warnings); + scan_windows(value, &child_path(path, "windows"), warnings); + scan_profiles(value, &child_path(path, "profiles"), warnings); + scan_mcp_servers(value, &child_path(path, "mcp_servers"), warnings); + scan_apps(value, &child_path(path, "apps"), warnings); + scan_plugins(value, &child_path(path, "plugins"), warnings); + scan_marketplaces(value, &child_path(path, "marketplaces"), warnings); } -/// Converts Serde's structured path into the TOML traversal path used below. -/// -/// Root-level or unknown paths are not safe to remove because they do not name -/// a specific user-authored key. -fn path_segments(path: &SerdePath) -> Option> { - let mut segments = Vec::new(); - for segment in path { - match segment { - SerdeSegment::Map { key } | SerdeSegment::Enum { variant: key } => { - segments.push(PathSegment::Key(key.clone())); - } - SerdeSegment::Seq { index } => segments.push(PathSegment::Index(*index)), - SerdeSegment::Unknown => return None, - } - } - (!segments.is_empty()).then_some(segments) -} - -/// Detects Serde's enum-variant failures without swallowing unrelated errors. -/// -/// toml::de::Error does not expose a structured enum-kind discriminator, so the -/// loader keeps the match deliberately narrow and lets all other parse and type -/// errors flow through the existing config-error path. -fn is_unknown_variant_error(err: &toml::de::Error) -> bool { - err.message().contains("unknown variant") -} - -/// Extracts the rejected enum variant from Serde's diagnostic string. -/// -/// The TOML error type does not expose this value directly, but Serde formats -/// enum errors consistently as `unknown variant \`value\``. The value lets us -/// recover a leaf key when Serde reports the containing table for flattened -/// config structs. -fn unknown_variant(err: &toml::de::Error) -> Option<&str> { - let message = err.message(); - let variant = message.strip_prefix("unknown variant `")?; - let (variant, _) = variant.split_once('`')?; - Some(variant) -} - -/// Detects the custom `tools.web_search` deserializer's collapsed error. -fn is_web_search_tool_config_input_error(err: &toml::de::Error) -> bool { - err.message() == WEB_SEARCH_TOOL_CONFIG_INPUT_ERROR -} - -/// Detects the untagged TUI notification setting error. -fn is_notifications_error(err: &toml::de::Error) -> bool { - err.message() == NOTIFICATIONS_ERROR -} - -/// Removes an ordinary enum leaf, but only when the TOML value matches the -/// rejected variant Serde reported. -fn remove_unknown_variant_value( +fn scan_shell_environment_policy( value: &mut TomlValue, - path: &[PathSegment], - unknown_variant: Option<&str>, - original_message: &str, -) -> Option<(Vec, TomlValue)> + path: &[String], + warnings: &mut Vec, +) { + check_fields!( + value, + path, + warnings, + "inherit" => ShellEnvironmentPolicyInherit, + ); +} + +fn scan_history(value: &mut TomlValue, path: &[String], warnings: &mut Vec) { + check_fields!( + value, + path, + warnings, + "persistence" => HistoryPersistence, + ); +} + +fn scan_tui(value: &mut TomlValue, path: &[String], warnings: &mut Vec) { + check_fields!( + value, + path, + warnings, + "notifications" => Notifications, + "notification_method" => NotificationMethod, + "notification_condition" => NotificationCondition, + "alternate_screen" => AltScreenMode, + "session_picker_view" => SessionPickerViewMode, + ); +} + +fn scan_realtime(value: &mut TomlValue, path: &[String], warnings: &mut Vec) { + check_fields!( + value, + path, + warnings, + "version" => RealtimeWsVersion, + "type" => RealtimeWsMode, + "transport" => RealtimeTransport, + "voice" => RealtimeVoice, + ); +} + +fn scan_tools(value: &mut TomlValue, path: &[String], warnings: &mut Vec) { + check_fields!( + value, + &child_path(path, "web_search"), + warnings, + CONTEXT_SIZE => WebSearchContextSize, + ); +} + +fn scan_windows(value: &mut TomlValue, path: &[String], warnings: &mut Vec) { + check_fields!( + value, + path, + warnings, + "sandbox" => WindowsSandboxModeToml, + ); +} + +fn scan_profiles(value: &mut TomlValue, path: &[String], warnings: &mut Vec) { + for profile_path in child_table_paths(value, path) { + scan_profile(value, &profile_path, warnings); + } +} + +fn scan_profile(value: &mut TomlValue, path: &[String], warnings: &mut Vec) { + check_fields!( + value, + path, + warnings, + "service_tier" => ServiceTier, + "approval_policy" => AskForApproval, + "approvals_reviewer" => ApprovalsReviewer, + "sandbox_mode" => SandboxMode, + "model_reasoning_effort" => ReasoningEffort, + "plan_mode_reasoning_effort" => ReasoningEffort, + "model_reasoning_summary" => ReasoningSummary, + "model_verbosity" => Verbosity, + "personality" => Personality, + "web_search" => WebSearchMode, + ); + scan_tools(value, &child_path(path, "tools"), warnings); + scan_windows(value, &child_path(path, "windows"), warnings); + check_fields!( + value, + &child_path(path, "tui"), + warnings, + "session_picker_view" => SessionPickerViewMode, + ); +} + +fn scan_mcp_servers(value: &mut TomlValue, path: &[String], warnings: &mut Vec) { + for server_path in child_table_paths(value, path) { + scan_tool_approval_overrides(value, &server_path, warnings); + } +} + +fn scan_apps(value: &mut TomlValue, path: &[String], warnings: &mut Vec) { + for app_path in child_table_paths(value, path) { + scan_tool_approval_overrides(value, &app_path, warnings); + } +} + +fn scan_plugins(value: &mut TomlValue, path: &[String], warnings: &mut Vec) { + for plugin_path in child_table_paths(value, path) { + for server_path in child_table_paths(value, &child_path(&plugin_path, "mcp_servers")) { + scan_tool_approval_overrides(value, &server_path, warnings); + } + } +} + +fn scan_tool_approval_overrides( + value: &mut TomlValue, + path: &[String], + warnings: &mut Vec, +) { + check_fields!( + value, + path, + warnings, + DEFAULT_TOOLS_APPROVAL_MODE => AppToolApproval, + ); + for tool_path in child_table_paths(value, &child_path(path, "tools")) { + check_fields!( + value, + &tool_path, + warnings, + APPROVAL_MODE => AppToolApproval, + ); + } +} + +fn scan_marketplaces(value: &mut TomlValue, path: &[String], warnings: &mut Vec) { + for marketplace_path in child_table_paths(value, path) { + check_fields!( + value, + &marketplace_path, + warnings, + "source_type" => MarketplaceSourceType, + ); + } +} + +/// Checks one known enum leaf by parsing the raw TOML value as the real field type. +fn check_value(value: &mut TomlValue, path: &[String], warnings: &mut Vec) where T: DeserializeOwned, { - let variant = unknown_variant?; - if value_at_segments(value, path).and_then(TomlValue::as_str) == Some(variant) { - return remove_value_at_segments(value, path).map(|removed| (path.to_vec(), removed)); + let Some(raw_value) = value_at_path(value, path) else { + return; + }; + if raw_value.clone().try_into::().is_ok() { + return; } - remove_direct_string_child_that_unblocks::(value, path, variant, original_message) + let Some(invalid_value) = remove_value_at_path(value, path) else { + return; + }; + warnings.push(format!( + "Ignoring invalid config value at {}: {invalid_value}", + display_path(path) + )); } -/// Removes `tools.web_search.context_size` after the untagged table/boolean -/// deserializer hides the inner enum error. -/// -/// The explicit path keeps this from swallowing unrelated `tools.web_search` -/// shape errors such as a bad `allowed_domains` value. -fn remove_invalid_web_search_context_size( - value: &mut TomlValue, - web_search_path: &[PathSegment], -) -> Option<(Vec, TomlValue)> { - remove_invalid_leaf_value::(value, web_search_path, CONTEXT_SIZE_KEY) +/// Returns table child paths in TOML map order without holding a borrow. +fn child_table_paths(value: &TomlValue, path: &[String]) -> Vec> { + let Some(table) = value_at_path(value, path).and_then(TomlValue::as_table) else { + return Vec::new(); + }; + table + .iter() + .filter_map(|(key, value)| value.is_table().then(|| child_path(path, key))) + .collect() } -/// Removes `tui.notifications` when its untagged bool/list parser fails. -/// -/// This is separate from ordinary enum handling because Serde's untagged error -/// does not include the rejected value text. The candidate path is constrained -/// to the `notifications` leaf so a flattened-parent error cannot delete the -/// entire `[tui]` table. -fn remove_invalid_notifications_value( - value: &mut TomlValue, - path: &[PathSegment], -) -> Option<(Vec, TomlValue)> { - remove_invalid_leaf_value::(value, path, NOTIFICATIONS_KEY) -} - -/// Reads a TOML value by structured path without flattening map keys into text. -fn value_at_segments<'a>(value: &'a TomlValue, segments: &[PathSegment]) -> Option<&'a TomlValue> { +fn value_at_path<'a>(value: &'a TomlValue, path: &[String]) -> Option<&'a TomlValue> { let mut current = value; - for segment in segments { - match segment { - PathSegment::Key(key) => current = current.as_table()?.get(key)?, - PathSegment::Index(index) => current = current.as_array()?.get(*index)?, - } + for key in path { + current = current.as_table()?.get(key)?; } Some(current) } -/// Removes a flattened enum child only after proving it unblocks parsing. -/// -/// For `#[serde(flatten)]`, serde_path_to_error can report the containing -/// table instead of the enum leaf. Recursing through the whole subtree can -/// remove the wrong setting, so this fallback only tries direct string children -/// with the rejected value and accepts exactly one child that moves -/// deserialization past the original error. -fn remove_direct_string_child_that_unblocks( - value: &mut TomlValue, - path: &[PathSegment], - variant: &str, - original_message: &str, -) -> Option<(Vec, TomlValue)> -where - T: DeserializeOwned, -{ - let mut unblocking_key = None; - for end in (0..=path.len()).rev() { - let parent_path = &path[..end]; - let Some(table) = value_at_segments(value, parent_path).and_then(TomlValue::as_table) - else { - continue; - }; - let keys = table - .iter() - .filter_map(|(key, child)| (child.as_str() == Some(variant)).then_some(key.clone())) - .collect::>(); - - for key in keys { - let mut child_path = parent_path.to_vec(); - child_path.push(PathSegment::Key(key.clone())); - - let mut candidate_value = value.clone(); - remove_value_at_segments(&mut candidate_value, &child_path)?; - let parsed: Result> = - serde_path_to_error::deserialize(candidate_value); - let removes_original_error = match parsed { - Ok(_) => true, - Err(err) => { - path_segments(err.path()).as_deref() != Some(path) - || err.inner().message() != original_message - } - }; - if !removes_original_error { - continue; - } - if unblocking_key - .replace((parent_path.to_vec(), key)) - .is_some() - { - return None; - } - } - } - - let (mut child_path, key) = unblocking_key?; - child_path.push(PathSegment::Key(key)); - remove_value_at_segments(value, &child_path).map(|removed| (child_path, removed)) -} - -/// Removes a named leaf after proving that leaf still fails typed parsing. -/// -/// Untagged enum errors can point at a containing table, or at an internal -/// deserializer segment that is not a real TOML key. Walking ancestors lets us -/// recover `path.leaf` without ever searching unrelated descendants. -fn remove_invalid_leaf_value( - value: &mut TomlValue, - path: &[PathSegment], - leaf: &str, -) -> Option<(Vec, TomlValue)> -where - T: DeserializeOwned, -{ - for end in (0..=path.len()).rev() { - let mut candidate = path[..end].to_vec(); - if !candidate - .last() - .is_some_and(|segment| matches!(segment, PathSegment::Key(key) if key == leaf)) - { - candidate.push(PathSegment::Key(leaf.to_string())); - } - - let parsed: Result = { - let Some(raw_value) = value_at_segments(value, &candidate) else { - continue; - }; - raw_value.clone().try_into() - }; - if parsed.is_ok() { - return None; - } - return remove_value_at_segments(value, &candidate).map(|removed| (candidate, removed)); - } - - None -} - -/// Deletes the offending TOML value by structured path. -fn remove_value_at_segments(value: &mut TomlValue, segments: &[PathSegment]) -> Option { - let (last, parents) = segments.split_last()?; +fn remove_value_at_path(value: &mut TomlValue, path: &[String]) -> Option { + let (last, parents) = path.split_last()?; let mut current = value; - for segment in parents { - match segment { - PathSegment::Key(key) => current = current.as_table_mut()?.get_mut(key)?, - PathSegment::Index(index) => current = current.as_array_mut()?.get_mut(*index)?, - } - } - match last { - PathSegment::Key(key) => current.as_table_mut()?.remove(key), - PathSegment::Index(index) => { - let array = current.as_array_mut()?; - if *index >= array.len() { - return None; - } - Some(array.remove(*index)) - } + for key in parents { + current = current.as_table_mut()?.get_mut(key)?; } + current.as_table_mut()?.remove(last) } -/// Formats paths for warnings, quoting literal table keys that contain dots. -fn display_path(segments: &[PathSegment]) -> String { - let mut path = String::new(); - for segment in segments { - match segment { - PathSegment::Key(key) => { - if !path.is_empty() { - path.push('.'); - } - path.push_str(&display_key(key)); - } - PathSegment::Index(index) => path.push_str(&format!("[{index}]")), - } - } - path +fn child_path(path: &[String], key: &str) -> Vec { + let mut child = path.to_vec(); + child.push(key.to_string()); + child +} + +fn display_path(path: &[String]) -> String { + path.iter() + .map(|key| display_key(key)) + .collect::>() + .join(".") } -/// Formats one TOML key segment for warning paths. fn display_key(key: &str) -> String { if !key.is_empty() && key diff --git a/codex-rs/config/src/loader/mod.rs b/codex-rs/config/src/loader/mod.rs index 42b80328fa..55779b075e 100644 --- a/codex-rs/config/src/loader/mod.rs +++ b/codex-rs/config/src/loader/mod.rs @@ -877,7 +877,7 @@ pub fn resolve_relative_paths_in_config_toml( // the final config load can still surface the startup warning. let _guard = AbsolutePathBufGuard::new(base_dir); let Ok((_sanitized, resolved, _enum_warnings)) = - deserialize_with_enum_warnings::(value_from_config_toml.clone()) + deserialize_with_enum_warnings(value_from_config_toml.clone()) else { return Ok(value_from_config_toml); }; diff --git a/codex-rs/config/src/mcp_types.rs b/codex-rs/config/src/mcp_types.rs index d642d9fc57..ef8ab4ed53 100644 --- a/codex-rs/config/src/mcp_types.rs +++ b/codex-rs/config/src/mcp_types.rs @@ -10,6 +10,8 @@ use serde::Deserialize; use serde::Deserializer; use serde::Serialize; use serde::de::Error as SerdeError; +use serde_with::DefaultOnError; +use serde_with::serde_as; use crate::RequirementSource; @@ -48,11 +50,13 @@ impl fmt::Display for McpServerDisabledReason { } /// Per-tool approval settings for a single MCP server tool. +#[serde_as] #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Default, JsonSchema)] #[schemars(deny_unknown_fields)] pub struct McpServerToolConfig { /// Approval mode for this tool. #[serde(default, skip_serializing_if = "Option::is_none")] + #[serde_as(deserialize_as = "DefaultOnError")] pub approval_mode: Option, } @@ -185,6 +189,7 @@ pub struct McpServerConfig { /// Keep `TryFrom for McpServerConfig` exhaustively /// destructuring this struct so new TOML fields cannot be added here without /// updating the validation/mapping logic that produces [`McpServerConfig`]. +#[serde_as] #[derive(Deserialize, Clone, JsonSchema)] #[schemars(deny_unknown_fields)] pub struct RawMcpServerConfig { @@ -225,6 +230,7 @@ pub struct RawMcpServerConfig { #[serde(default)] pub supports_parallel_tool_calls: Option, #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub default_tools_approval_mode: Option, #[serde(default)] pub enabled_tools: Option>, diff --git a/codex-rs/config/src/profile_toml.rs b/codex-rs/config/src/profile_toml.rs index fab78a128c..c17f46937c 100644 --- a/codex-rs/config/src/profile_toml.rs +++ b/codex-rs/config/src/profile_toml.rs @@ -2,6 +2,8 @@ use codex_utils_absolute_path::AbsolutePathBuf; use schemars::JsonSchema; use serde::Deserialize; use serde::Serialize; +use serde_with::DefaultOnError; +use serde_with::serde_as; use crate::config_toml::ToolsToml; use crate::types::AnalyticsConfigToml; @@ -20,24 +22,43 @@ use codex_protocol::protocol::AskForApproval; /// Collection of common configuration options that a user can define as a unit /// in `config.toml`. +#[serde_as] #[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize, JsonSchema)] #[schemars(deny_unknown_fields)] pub struct ConfigProfile { pub model: Option, /// Optional explicit service tier preference for new turns (`fast` or `flex`). + #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub service_tier: Option, /// The key in the `model_providers` map identifying the /// [`ModelProviderInfo`] to use. pub model_provider: Option, + #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub approval_policy: Option, + #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub approvals_reviewer: Option, + #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub sandbox_mode: Option, + #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub model_reasoning_effort: Option, + #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub plan_mode_reasoning_effort: Option, + #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub model_reasoning_summary: Option, + #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub model_verbosity: Option, /// Optional path to a JSON model catalog (applied on startup only). pub model_catalog_json: Option, + #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub personality: Option, pub chatgpt_base_url: Option, /// Optional path to a file containing model instructions. @@ -62,6 +83,8 @@ pub struct ConfigProfile { pub experimental_use_freeform_apply_patch: Option, pub tools_view_image: Option, pub tools: Option, + #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub web_search: Option, pub analytics: Option, /// TUI settings scoped to this profile. @@ -78,12 +101,14 @@ pub struct ConfigProfile { } /// TUI settings supported inside a named profile. +#[serde_as] #[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize, JsonSchema)] #[serde(deny_unknown_fields)] #[schemars(deny_unknown_fields)] pub struct ProfileTui { /// Preferred layout for resume/fork session picker results. #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub session_picker_view: Option, } diff --git a/codex-rs/config/src/state.rs b/codex-rs/config/src/state.rs index 371e862b70..6961c7a253 100644 --- a/codex-rs/config/src/state.rs +++ b/codex-rs/config/src/state.rs @@ -6,6 +6,7 @@ use super::fingerprint::version_for_toml; use super::key_aliases::normalized_with_key_aliases; use super::lenient::deserialize_with_enum_warnings; use super::merge::merge_toml_values; +use crate::config_toml::ConfigToml; use codex_app_server_protocol::ConfigLayer; use codex_app_server_protocol::ConfigLayerMetadata; use codex_app_server_protocol::ConfigLayerSource; @@ -323,12 +324,9 @@ impl ConfigLayerStack { /// invalid enum values while consumers still receive a fully typed config. /// Each layer is sanitized before it is merged so a higher-precedence /// invalid enum value falls back to a valid lower-precedence value. - pub fn deserialize_effective_config_with_warnings( + pub fn deserialize_effective_config_with_warnings( &self, - ) -> Result<(TomlValue, T, Vec), toml::de::Error> - where - T: serde::de::DeserializeOwned, - { + ) -> Result<(TomlValue, ConfigToml, Vec), toml::de::Error> { let mut merged = TomlValue::Table(toml::map::Map::new()); let mut warnings = Vec::new(); @@ -339,13 +337,13 @@ impl ConfigLayerStack { let mut normalized_layer = TomlValue::Table(toml::map::Map::new()); merge_toml_values(&mut normalized_layer, &layer.config); let (sanitized_layer, _typed_layer, layer_warnings) = - deserialize_with_enum_warnings::(normalized_layer)?; + deserialize_with_enum_warnings(normalized_layer)?; warnings.extend(layer_warnings); merge_toml_values(&mut merged, &sanitized_layer); } let (sanitized_effective, typed_effective, effective_warnings) = - deserialize_with_enum_warnings::(merged)?; + deserialize_with_enum_warnings(merged)?; warnings.extend(effective_warnings); Ok((sanitized_effective, typed_effective, warnings)) } diff --git a/codex-rs/config/src/types.rs b/codex-rs/config/src/types.rs index 6cb9abc507..134bfb13cd 100644 --- a/codex-rs/config/src/types.rs +++ b/codex-rs/config/src/types.rs @@ -27,6 +27,8 @@ use std::fmt; use schemars::JsonSchema; use serde::Deserialize; use serde::Serialize; +use serde_with::DefaultOnError; +use serde_with::serde_as; pub use crate::tui_keymap::KeybindingSpec; pub use crate::tui_keymap::KeybindingsSpec; @@ -118,9 +120,12 @@ pub enum WindowsSandboxModeToml { Unelevated, } +#[serde_as] #[derive(Serialize, Deserialize, Debug, Clone, Default, PartialEq, Eq, JsonSchema)] #[schemars(deny_unknown_fields)] pub struct WindowsToml { + #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub sandbox: Option, /// Defaults to `true`. Set to `false` to launch the final sandboxed child /// process on `Winsta0\\Default` instead of a private desktop. @@ -159,11 +164,13 @@ impl UriBasedFileOpener { } /// Settings that govern if and what will be written to `~/.codex/history.jsonl`. +#[serde_as] #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default, JsonSchema)] #[serde(default)] #[schemars(deny_unknown_fields)] pub struct History { /// If true, history entries will not be written to disk. + #[serde_as(deserialize_as = "DefaultOnError")] pub persistence: HistoryPersistence, /// If set, the maximum size of the history file in bytes. The oldest entries @@ -389,6 +396,7 @@ pub struct AppsDefaultConfig { } /// Per-tool settings for a single app tool. +#[serde_as] #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Default, JsonSchema)] #[schemars(deny_unknown_fields)] pub struct AppToolConfig { @@ -398,6 +406,7 @@ pub struct AppToolConfig { /// Approval mode for this tool. #[serde(default, skip_serializing_if = "Option::is_none")] + #[serde_as(deserialize_as = "DefaultOnError")] pub approval_mode: Option, } @@ -411,6 +420,7 @@ pub struct AppToolsConfig { } /// Config values for a single app/connector. +#[serde_as] #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default, JsonSchema)] #[schemars(deny_unknown_fields)] pub struct AppConfig { @@ -428,6 +438,7 @@ pub struct AppConfig { /// Approval mode for tools in this app unless a tool override exists. #[serde(default, skip_serializing_if = "Option::is_none")] + #[serde_as(deserialize_as = "DefaultOnError")] pub default_tools_approval_mode: Option, /// Whether tools are enabled by default for this app. @@ -589,22 +600,26 @@ impl fmt::Display for NotificationCondition { } } +#[serde_as] #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Default, JsonSchema)] #[schemars(deny_unknown_fields)] pub struct TuiNotificationSettings { /// Enable desktop notifications from the TUI. /// Defaults to `true`. #[serde(default, rename = "notifications")] + #[serde_as(deserialize_as = "DefaultOnError")] pub notifications: Notifications, /// Notification method to use for terminal notifications. /// Defaults to `auto`. #[serde(default, rename = "notification_method")] + #[serde_as(deserialize_as = "DefaultOnError")] pub method: NotificationMethod, /// Controls whether TUI notifications are delivered only when the terminal is unfocused or /// regardless of focus. Defaults to `unfocused`. #[serde(default, rename = "notification_condition")] + #[serde_as(deserialize_as = "DefaultOnError")] pub condition: NotificationCondition, } @@ -620,6 +635,7 @@ pub struct ModelAvailabilityNuxConfig { pub const DEFAULT_TERMINAL_RESIZE_REFLOW_FALLBACK_MAX_ROWS: usize = 1_000; /// Collection of settings that are specific to the TUI. +#[serde_as] #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default, JsonSchema)] #[schemars(deny_unknown_fields)] pub struct Tui { @@ -655,6 +671,7 @@ pub struct Tui { /// Using alternate screen provides a cleaner fullscreen experience but prevents /// scrollback in terminal multiplexers like Zellij that follow the xterm spec. #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub alternate_screen: AltScreenMode, /// Ordered list of status line item identifiers. @@ -687,6 +704,7 @@ pub struct Tui { /// Preferred layout for resume/fork session picker results. #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub session_picker_view: Option, /// Keybinding overrides for the TUI. @@ -773,6 +791,7 @@ pub struct PluginConfig { /// /// This intentionally excludes transport settings: plugin manifests own how the /// MCP server is launched, while user config owns enablement and tool policy. +#[serde_as] #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, JsonSchema)] #[schemars(deny_unknown_fields)] pub struct PluginMcpServerConfig { @@ -782,6 +801,7 @@ pub struct PluginMcpServerConfig { /// Approval mode for tools in this server unless a tool override exists. #[serde(default, skip_serializing_if = "Option::is_none")] + #[serde_as(deserialize_as = "DefaultOnError")] pub default_tools_approval_mode: Option, /// Explicit allow-list of tools exposed from this server. @@ -809,6 +829,7 @@ impl Default for PluginMcpServerConfig { } } +#[serde_as] #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Default, JsonSchema)] #[schemars(deny_unknown_fields)] pub struct MarketplaceConfig { @@ -820,6 +841,7 @@ pub struct MarketplaceConfig { pub last_revision: Option, /// Source kind used to install this marketplace. #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub source_type: Option, /// Source location used when the marketplace was added. #[serde(default)] @@ -865,9 +887,12 @@ impl From for codex_app_server_protocol::SandboxSettings /// Policy for building the `env` when spawning a process via either the /// `shell` or `local_shell` tool. +#[serde_as] #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default, JsonSchema)] #[schemars(deny_unknown_fields)] pub struct ShellEnvironmentPolicyToml { + #[serde(default)] + #[serde_as(deserialize_as = "DefaultOnError")] pub inherit: Option, pub ignore_default_excludes: Option, diff --git a/codex-rs/core/config.schema.json b/codex-rs/core/config.schema.json index 9f74b8b7cf..730416aa76 100644 --- a/codex-rs/core/config.schema.json +++ b/codex-rs/core/config.schema.json @@ -336,10 +336,20 @@ "$ref": "#/definitions/AnalyticsConfigToml" }, "approval_policy": { - "$ref": "#/definitions/AskForApproval" + "allOf": [ + { + "$ref": "#/definitions/AskForApproval" + } + ], + "default": null }, "approvals_reviewer": { - "$ref": "#/definitions/ApprovalsReviewer" + "allOf": [ + { + "$ref": "#/definitions/ApprovalsReviewer" + } + ], + "default": null }, "chatgpt_base_url": { "type": "string" @@ -646,25 +656,55 @@ "type": "string" }, "model_reasoning_effort": { - "$ref": "#/definitions/ReasoningEffort" + "allOf": [ + { + "$ref": "#/definitions/ReasoningEffort" + } + ], + "default": null }, "model_reasoning_summary": { - "$ref": "#/definitions/ReasoningSummary" + "allOf": [ + { + "$ref": "#/definitions/ReasoningSummary" + } + ], + "default": null }, "model_verbosity": { - "$ref": "#/definitions/Verbosity" + "allOf": [ + { + "$ref": "#/definitions/Verbosity" + } + ], + "default": null }, "oss_provider": { "type": "string" }, "personality": { - "$ref": "#/definitions/Personality" + "allOf": [ + { + "$ref": "#/definitions/Personality" + } + ], + "default": null }, "plan_mode_reasoning_effort": { - "$ref": "#/definitions/ReasoningEffort" + "allOf": [ + { + "$ref": "#/definitions/ReasoningEffort" + } + ], + "default": null }, "sandbox_mode": { - "$ref": "#/definitions/SandboxMode" + "allOf": [ + { + "$ref": "#/definitions/SandboxMode" + } + ], + "default": null }, "service_tier": { "allOf": [ @@ -672,6 +712,7 @@ "$ref": "#/definitions/ServiceTier" } ], + "default": null, "description": "Optional explicit service tier preference for new turns (`fast` or `flex`)." }, "tools": { @@ -690,7 +731,12 @@ "description": "TUI settings scoped to this profile." }, "web_search": { - "$ref": "#/definitions/WebSearchMode" + "allOf": [ + { + "$ref": "#/definitions/WebSearchMode" + } + ], + "default": null }, "windows": { "allOf": [ @@ -2070,16 +2116,36 @@ "additionalProperties": false, "properties": { "transport": { - "$ref": "#/definitions/RealtimeTransport" + "allOf": [ + { + "$ref": "#/definitions/RealtimeTransport" + } + ], + "default": null }, "type": { - "$ref": "#/definitions/RealtimeWsMode" + "allOf": [ + { + "$ref": "#/definitions/RealtimeWsMode" + } + ], + "default": null }, "version": { - "$ref": "#/definitions/RealtimeConversationVersion" + "allOf": [ + { + "$ref": "#/definitions/RealtimeConversationVersion" + } + ], + "default": null }, "voice": { - "$ref": "#/definitions/RealtimeVoice" + "allOf": [ + { + "$ref": "#/definitions/RealtimeVoice" + } + ], + "default": null } }, "type": "object" @@ -2252,7 +2318,12 @@ "type": "array" }, "inherit": { - "$ref": "#/definitions/ShellEnvironmentPolicyInherit" + "allOf": [ + { + "$ref": "#/definitions/ShellEnvironmentPolicyInherit" + } + ], + "default": null }, "set": { "additionalProperties": { @@ -3723,7 +3794,12 @@ "additionalProperties": false, "properties": { "sandbox": { - "$ref": "#/definitions/WindowsSandboxModeToml" + "allOf": [ + { + "$ref": "#/definitions/WindowsSandboxModeToml" + } + ], + "default": null }, "sandbox_private_desktop": { "description": "Defaults to `true`. Set to `false` to launch the final sandboxed child process on `Winsta0\\\\Default` instead of a private desktop.", @@ -3774,6 +3850,7 @@ "$ref": "#/definitions/AskForApproval" } ], + "default": null, "description": "Default approval policy for executing commands." }, "approvals_reviewer": { @@ -3782,6 +3859,7 @@ "$ref": "#/definitions/ApprovalsReviewer" } ], + "default": null, "description": "Configures who approval requests are routed to for review once they have been escalated. This does not disable separate safety checks such as ARC." }, "apps": { @@ -3896,6 +3974,7 @@ "$ref": "#/definitions/ThreadStoreToml" } ], + "default": null, "description": "Experimental / do not use. Selects the thread store implementation." }, "experimental_thread_store_endpoint": { @@ -4179,6 +4258,7 @@ "$ref": "#/definitions/UriBasedFileOpener" } ], + "default": null, "description": "Optional URI-based file opener. If set, citations to files in the model output will be hyperlinked using the specified URI scheme." }, "forced_chatgpt_workspace_id": { @@ -4339,10 +4419,20 @@ "type": "object" }, "model_reasoning_effort": { - "$ref": "#/definitions/ReasoningEffort" + "allOf": [ + { + "$ref": "#/definitions/ReasoningEffort" + } + ], + "default": null }, "model_reasoning_summary": { - "$ref": "#/definitions/ReasoningSummary" + "allOf": [ + { + "$ref": "#/definitions/ReasoningSummary" + } + ], + "default": null }, "model_supports_reasoning_summaries": { "description": "Override to force-enable reasoning summaries for the configured model.", @@ -4354,6 +4444,7 @@ "$ref": "#/definitions/Verbosity" } ], + "default": null, "description": "Optional verbosity control for GPT-5 models (Responses API `text.verbosity`)." }, "notice": { @@ -4403,10 +4494,16 @@ "$ref": "#/definitions/Personality" } ], + "default": null, "description": "Optionally specify a personality for the model" }, "plan_mode_reasoning_effort": { - "$ref": "#/definitions/ReasoningEffort" + "allOf": [ + { + "$ref": "#/definitions/ReasoningEffort" + } + ], + "default": null }, "plugins": { "additionalProperties": { @@ -4476,6 +4573,7 @@ "$ref": "#/definitions/SandboxMode" } ], + "default": null, "description": "Sandbox mode to use." }, "sandbox_workspace_write": { @@ -4492,6 +4590,7 @@ "$ref": "#/definitions/ServiceTier" } ], + "default": null, "description": "Optional explicit service tier preference for new turns (`fast` or `flex`)." }, "shell_environment_policy": { @@ -4569,6 +4668,7 @@ "$ref": "#/definitions/WebSearchMode" } ], + "default": null, "description": "Controls the web search tool mode: disabled, cached, or live." }, "windows": { diff --git a/codex-rs/core/src/config/config_loader_tests.rs b/codex-rs/core/src/config/config_loader_tests.rs index 07da2813ed..9f5701b643 100644 --- a/codex-rs/core/src/config/config_loader_tests.rs +++ b/codex-rs/core/src/config/config_loader_tests.rs @@ -150,7 +150,7 @@ context_size = "galactic" // The invalid enum leaves are removed before ConfigToml is produced, but // unrelated valid settings still survive in the effective config. - let (effective_config, _config_toml, enum_warnings): (TomlValue, ConfigToml, Vec) = + let (effective_config, _config_toml, enum_warnings) = layers.deserialize_effective_config_with_warnings()?; let expected_config = toml::from_str::( r#" @@ -165,8 +165,8 @@ theme = "loudly" .expect("expected config should parse"); let expected_startup_warnings = vec![ "Ignoring invalid config value at sandbox_mode: \"make-it-so\"".to_string(), - "Ignoring invalid config value at tools.web_search.context_size: \"galactic\"".to_string(), "Ignoring invalid config value at tui.notification_method: \"loudly\"".to_string(), + "Ignoring invalid config value at tools.web_search.context_size: \"galactic\"".to_string(), ]; assert_eq!( @@ -203,7 +203,7 @@ async fn invalid_higher_precedence_enum_falls_back_to_lower_layer() -> anyhow::R ) .await?; - let (effective_config, config_toml, enum_warnings): (TomlValue, ConfigToml, Vec) = + let (effective_config, config_toml, enum_warnings) = layers.deserialize_effective_config_with_warnings()?; assert_eq!( @@ -277,7 +277,7 @@ theme = "sometimes" ) .await?; - let (effective_config, _config_toml, enum_warnings): (TomlValue, ConfigToml, Vec) = + let (effective_config, _config_toml, enum_warnings) = layers.deserialize_effective_config_with_warnings()?; let expected = ( toml::from_str::( @@ -317,7 +317,7 @@ sandbox_mode = "hold-my-coffee" ) .await?; - let (effective_config, _config_toml, enum_warnings): (TomlValue, ConfigToml, Vec) = + let (effective_config, _config_toml, enum_warnings) = layers.deserialize_effective_config_with_warnings()?; let expected = ( toml::from_str::( diff --git a/codex-rs/core/src/config/mod.rs b/codex-rs/core/src/config/mod.rs index 55fa099b3e..4720ec575b 100644 --- a/codex-rs/core/src/config/mod.rs +++ b/codex-rs/core/src/config/mod.rs @@ -976,11 +976,11 @@ impl ConfigBuilder { // respective config file, so we should be safe to deserialize without // AbsolutePathBufGuard here. // - // Invalid enum-valued settings are dropped during deserialization and - // returned as warnings. This keeps ConfigToml strict and prevents raw - // invalid values from leaking into downstream config consumers. + // Invalid enum-valued settings default at the typed field boundary and + // are removed from the merged TOML view when the best-effort scan can + // identify the offending leaf. let (_merged_toml, config_toml, enum_warnings) = match config_layer_stack - .deserialize_effective_config_with_warnings::() + .deserialize_effective_config_with_warnings() { Ok(result) => result, Err(err) => { @@ -1309,7 +1309,7 @@ pub async fn load_config_as_toml_with_cli_and_loader_overrides( // not surfaced here. The full ConfigBuilder path is responsible for // attaching them to startup warnings. let (_merged_toml, cfg, _enum_warnings) = config_layer_stack - .deserialize_effective_config_with_warnings::() + .deserialize_effective_config_with_warnings() .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e)) .map_err(|e| { tracing::error!("Failed to deserialize overridden config: {e}");