comment

Author: celia-oai

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

@@ -6,6 +6,7 @@ use codex_protocol::account::PlanType;
 use codex_protocol::approvals::ExecPolicyAmendment as CoreExecPolicyAmendment;
 use codex_protocol::config_types::ForcedLoginMethod;
 use codex_protocol::config_types::ReasoningSummary;
+use codex_protocol::config_types::SandboxMode as CoreSandboxMode;
 use codex_protocol::config_types::Verbosity;
 use codex_protocol::items::AgentMessageContent as CoreAgentMessageContent;
 use codex_protocol::items::TurnItem as CoreTurnItem;
@@ -125,17 +126,68 @@ impl From<CoreCodexErrorInfo> for CodexErrorInfo {
     }
 }
 
-v2_enum_from_core!(
-    pub enum AskForApproval from codex_protocol::protocol::AskForApproval {
-        UnlessTrusted, OnFailure, OnRequest, Never
+#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq, JsonSchema, TS)]
+#[serde(rename_all = "kebab-case")]
+#[ts(rename_all = "kebab-case", export_to = "v2/")]
+pub enum AskForApproval {
+    #[serde(rename = "untrusted")]
+    #[ts(rename = "untrusted")]
+    UnlessTrusted,
+    OnFailure,
+    OnRequest,
+    Never,
+}
+
+impl AskForApproval {
+    pub fn to_core(self) -> CoreAskForApproval {
+        match self {
+            AskForApproval::UnlessTrusted => CoreAskForApproval::UnlessTrusted,
+            AskForApproval::OnFailure => CoreAskForApproval::OnFailure,
+            AskForApproval::OnRequest => CoreAskForApproval::OnRequest,
+            AskForApproval::Never => CoreAskForApproval::Never,
+        }
     }
-);
+}
 
-v2_enum_from_core!(
-    pub enum SandboxMode from codex_protocol::config_types::SandboxMode {
-        ReadOnly, WorkspaceWrite, DangerFullAccess
+impl From<CoreAskForApproval> for AskForApproval {
+    fn from(value: CoreAskForApproval) -> Self {
+        match value {
+            CoreAskForApproval::UnlessTrusted => AskForApproval::UnlessTrusted,
+            CoreAskForApproval::OnFailure => AskForApproval::OnFailure,
+            CoreAskForApproval::OnRequest => AskForApproval::OnRequest,
+            CoreAskForApproval::Never => AskForApproval::Never,
+        }
     }
-);
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq, JsonSchema, TS)]
+#[serde(rename_all = "kebab-case")]
+#[ts(rename_all = "kebab-case", export_to = "v2/")]
+pub enum SandboxMode {
+    ReadOnly,
+    WorkspaceWrite,
+    DangerFullAccess,
+}
+
+impl SandboxMode {
+    pub fn to_core(self) -> CoreSandboxMode {
+        match self {
+            SandboxMode::ReadOnly => CoreSandboxMode::ReadOnly,
+            SandboxMode::WorkspaceWrite => CoreSandboxMode::WorkspaceWrite,
+            SandboxMode::DangerFullAccess => CoreSandboxMode::DangerFullAccess,
+        }
+    }
+}
+
+impl From<CoreSandboxMode> for SandboxMode {
+    fn from(value: CoreSandboxMode) -> Self {
+        match value {
+            CoreSandboxMode::ReadOnly => SandboxMode::ReadOnly,
+            CoreSandboxMode::WorkspaceWrite => SandboxMode::WorkspaceWrite,
+            CoreSandboxMode::DangerFullAccess => SandboxMode::DangerFullAccess,
+        }
+    }
+}
 
 v2_enum_from_core!(
     pub enum ReviewDelivery from codex_protocol::protocol::ReviewDelivery {
@@ -240,6 +292,9 @@ pub struct Config {
     pub additional: HashMap<String, JsonValue>,
 }
 
+/// Keep config read/write compatible with kebab-case values from `config.toml`
+/// by round-tripping through the core enum (which is kebab-case) before
+/// mapping to the v2 enum.
 fn deserialize_approval_policy<'de, D>(deserializer: D) -> Result<Option<AskForApproval>, D::Error>
 where
     D: serde::Deserializer<'de>,
@@ -248,6 +303,8 @@ where
     Ok(value.map(AskForApproval::from))
 }
 
+/// Serialize using the kebab-case core enum so config responses match
+/// existing `config.toml` values.
 fn serialize_approval_policy<S>(
     value: &Option<AskForApproval>,
     serializer: S,
@@ -257,25 +314,31 @@ where
 {
     value
         .as_ref()
-        .map(|policy| policy.to_core())
+        .copied()
+        .map(AskForApproval::to_core)
         .serialize(serializer)
 }
 
+/// Preserve kebab-case sandbox_mode values from `config.toml` by deserializing
+/// via the core enum before converting to the v2 enum.
 fn deserialize_sandbox_mode<'de, D>(deserializer: D) -> Result<Option<SandboxMode>, D::Error>
 where
     D: serde::Deserializer<'de>,
 {
-    let value = Option::<codex_protocol::config_types::SandboxMode>::deserialize(deserializer)?;
+    let value = Option::<CoreSandboxMode>::deserialize(deserializer)?;
     Ok(value.map(SandboxMode::from))
 }
 
+/// Serialize sandbox_mode using the kebab-case core enum so config endpoints
+/// emit values that align with `config.toml`.
 fn serialize_sandbox_mode<S>(value: &Option<SandboxMode>, serializer: S) -> Result<S::Ok, S::Error>
 where
     S: serde::Serializer,
 {
     value
         .as_ref()
-        .map(|mode| mode.to_core())
+        .copied()
+        .map(SandboxMode::to_core)
         .serialize(serializer)
 }