snake case camel case shenanigans

Author: celia-oai

codex-rs/app-server-protocol/src/protocol/v2.rs

@@ -166,21 +166,23 @@ pub enum ConfigLayerName {
 #[serde(rename_all = "camelCase")]
 #[ts(export_to = "v2/")]
 pub struct SandboxWorkspaceWrite {
-    #[serde(default)]
+    #[serde(default, alias = "writable_roots")]
     pub writable_roots: Vec<PathBuf>,
-    #[serde(default)]
+    #[serde(default, alias = "network_access")]
     pub network_access: bool,
-    #[serde(default)]
+    #[serde(default, alias = "exclude_tmpdir_env_var")]
     pub exclude_tmpdir_env_var: bool,
-    #[serde(default)]
+    #[serde(default, alias = "exclude_slash_tmp")]
     pub exclude_slash_tmp: bool,
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
 #[serde(rename_all = "camelCase")]
 #[ts(export_to = "v2/")]
 pub struct ToolsV2 {
+    #[serde(alias = "web_search")]
     pub web_search: Option<bool>,
+    #[serde(alias = "view_image")]
     pub view_image: Option<bool>,
 }
 
@@ -189,16 +191,22 @@ pub struct ToolsV2 {
 #[ts(export_to = "v2/")]
 pub struct ProfileV2 {
     pub model: Option<String>,
+    #[serde(alias = "model_provider")]
     pub model_provider: Option<String>,
     #[serde(
         default,
         deserialize_with = "deserialize_approval_policy",
-        serialize_with = "serialize_approval_policy"
+        serialize_with = "serialize_approval_policy",
+        alias = "approval_policy"
     )]
     pub approval_policy: Option<AskForApproval>,
+    #[serde(alias = "model_reasoning_effort")]
     pub model_reasoning_effort: Option<ReasoningEffort>,
+    #[serde(alias = "model_reasoning_summary")]
     pub model_reasoning_summary: Option<ReasoningSummary>,
+    #[serde(alias = "model_verbosity")]
     pub model_verbosity: Option<Verbosity>,
+    #[serde(alias = "chatgpt_base_url")]
     pub chatgpt_base_url: Option<String>,
 }
 
@@ -207,36 +215,50 @@ pub struct ProfileV2 {
 #[ts(export_to = "v2/")]
 pub struct Config {
     pub model: Option<String>,
+    #[serde(alias = "review_model")]
     pub review_model: Option<String>,
+    #[serde(alias = "model_context_window")]
     pub model_context_window: Option<i64>,
+    #[serde(alias = "model_auto_compact_token_limit")]
     pub model_auto_compact_token_limit: Option<i64>,
+    #[serde(alias = "model_provider")]
     pub model_provider: Option<String>,
     #[serde(
         default,
         deserialize_with = "deserialize_approval_policy",
-        serialize_with = "serialize_approval_policy"
+        serialize_with = "serialize_approval_policy",
+        alias = "approval_policy"
     )]
     pub approval_policy: Option<AskForApproval>,
     #[serde(
         default,
         deserialize_with = "deserialize_sandbox_mode",
-        serialize_with = "serialize_sandbox_mode"
+        serialize_with = "serialize_sandbox_mode",
+        alias = "sandbox_mode"
     )]
     pub sandbox_mode: Option<SandboxMode>,
+    #[serde(alias = "sandbox_workspace_write")]
     pub sandbox_workspace_write: Option<SandboxWorkspaceWrite>,
+    #[serde(alias = "forced_chatgpt_workspace_id")]
     pub forced_chatgpt_workspace_id: Option<String>,
+    #[serde(alias = "forced_login_method")]
     pub forced_login_method: Option<ForcedLoginMethod>,
     pub tools: Option<ToolsV2>,
     pub profile: Option<String>,
     #[serde(default)]
     pub profiles: HashMap<String, ProfileV2>,
     pub instructions: Option<String>,
+    #[serde(alias = "developer_instructions")]
     pub developer_instructions: Option<String>,
+    #[serde(alias = "compact_prompt")]
     pub compact_prompt: Option<String>,
+    #[serde(alias = "model_reasoning_effort")]
     pub model_reasoning_effort: Option<ReasoningEffort>,
+    #[serde(alias = "model_reasoning_summary")]
     pub model_reasoning_summary: Option<ReasoningSummary>,
+    #[serde(alias = "model_verbosity")]
     pub model_verbosity: Option<Verbosity>,
-    #[serde(default, flatten)]
+    #[serde(default, flatten, deserialize_with = "deserialize_additional")]
     pub additional: HashMap<String, JsonValue>,
 }
 
@@ -279,6 +301,38 @@ where
         .serialize(serializer)
 }
 
+fn deserialize_additional<'de, D>(deserializer: D) -> Result<HashMap<String, JsonValue>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    let raw = HashMap::<String, JsonValue>::deserialize(deserializer)?;
+    Ok(raw
+        .into_iter()
+        .map(|(key, value)| (snake_to_camel(&key), value))
+        .collect())
+}
+
+fn snake_to_camel(input: &str) -> String {
+    let mut output = String::with_capacity(input.len());
+    let mut upper_next = false;
+
+    for ch in input.chars() {
+        if ch == '_' {
+            upper_next = true;
+            continue;
+        }
+
+        if upper_next {
+            output.push(ch.to_ascii_uppercase());
+            upper_next = false;
+        } else {
+            output.push(ch);
+        }
+    }
+
+    output
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
 #[serde(rename_all = "camelCase")]
 #[ts(export_to = "v2/")]
@@ -1840,7 +1894,7 @@ mod tests {
 
         assert_eq!(
             config.tools,
-            Some(Tools {
+            Some(ToolsV2 {
                 web_search: Some(true),
                 view_image: Some(false),
             })

codex-rs/app-server/tests/suite/v2/config_rpc.rs

@@ -14,6 +14,7 @@ use codex_app_server_protocol::JSONRPCResponse;
 use codex_app_server_protocol::MergeStrategy;
 use codex_app_server_protocol::RequestId;
 use codex_app_server_protocol::SandboxMode;
+use codex_app_server_protocol::ToolsV2;
 use codex_app_server_protocol::WriteStatus;
 use pretty_assertions::assert_eq;
 use serde_json::json;
@@ -73,6 +74,64 @@ sandbox_mode = "workspace-write"
     Ok(())
 }
 
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn config_read_includes_tools() -> Result<()> {
+    let codex_home = TempDir::new()?;
+    write_config(
+        &codex_home,
+        r#"
+model = "gpt-user"
+
+[tools]
+web_search = true
+view_image = false
+"#,
+    )?;
+
+    let mut mcp = McpProcess::new(codex_home.path()).await?;
+    timeout(DEFAULT_READ_TIMEOUT, mcp.initialize()).await??;
+
+    let request_id = mcp
+        .send_config_read_request(ConfigReadParams {
+            include_layers: true,
+        })
+        .await?;
+    let resp: JSONRPCResponse = timeout(
+        DEFAULT_READ_TIMEOUT,
+        mcp.read_stream_until_response_message(RequestId::Integer(request_id)),
+    )
+    .await??;
+    let ConfigReadResponse {
+        config,
+        origins,
+        layers,
+    } = to_response(resp)?;
+
+    let tools = config.tools.expect("tools present");
+    assert_eq!(
+        tools,
+        ToolsV2 {
+            web_search: Some(true),
+            view_image: Some(false),
+        }
+    );
+    assert_eq!(
+        origins.get("tools.web_search").expect("origin").name,
+        ConfigLayerName::User
+    );
+    assert_eq!(
+        origins.get("tools.view_image").expect("origin").name,
+        ConfigLayerName::User
+    );
+
+    let layers = layers.expect("layers present");
+    assert_eq!(layers.len(), 2);
+    assert_eq!(layers[0].name, ConfigLayerName::SessionFlags);
+    assert_eq!(layers[1].name, ConfigLayerName::User);
+
+    Ok(())
+}
+
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn config_read_includes_system_layer_and_overrides() -> Result<()> {
     let codex_home = TempDir::new()?;