Address review comments: update method name to configRequirements/read

Author: shijie-oai

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

@@ -197,9 +197,9 @@ client_request_definitions! {
         response: v2::ConfigWriteResponse,
     },
 
-    RequirementList => "requirements/list" {
+    ConfigRequirementsRead => "configRequirements/read" {
         params: #[ts(type = "undefined")] #[serde(skip_serializing_if = "Option::is_none")] Option<()>,
-        response: v2::RequirementListResponse,
+        response: v2::ConfigRequirementsReadResponse,
     },
 
     GetAccount => "account/read" {
@@ -716,6 +716,22 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn serialize_config_requirements_read() -> Result<()> {
+        let request = ClientRequest::ConfigRequirementsRead {
+            request_id: RequestId::Integer(1),
+            params: None,
+        };
+        assert_eq!(
+            json!({
+                "method": "configRequirements/read",
+                "id": 1,
+            }),
+            serde_json::to_value(&request)?,
+        );
+        Ok(())
+    }
+
     #[test]
     fn serialize_account_login_api_key() -> Result<()> {
         let request = ClientRequest::LoginAccount {

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

@@ -464,7 +464,7 @@ pub struct Requirements {
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
 #[serde(rename_all = "camelCase")]
 #[ts(export_to = "v2/")]
-pub struct RequirementListResponse {
+pub struct ConfigRequirementsReadResponse {
     /// Null if no requirements are configured (e.g. no requirements.toml/MDM entries).
     pub requirements: Option<Requirements>,
 }

codex-rs/app-server/README.md

@@ -88,7 +88,7 @@ Example (from OpenAI's official VSCode extension):
 - `config/read` — fetch the effective config on disk after resolving config layering.
 - `config/value/write` — write a single config key/value to the user's config.toml on disk.
 - `config/batchWrite` — apply multiple config edits atomically to the user's config.toml on disk.
-- `requirements/list` — fetch the loaded requirements allow-lists from `requirements.toml` and/or MDM (or `null` if none are configured).
+- `configRequirements/read` — fetch the loaded requirements allow-lists from `requirements.toml` and/or MDM (or `null` if none are configured).
 
 ### Example: Start or resume a thread
 

codex-rs/app-server/src/codex_message_processor.rs

@@ -510,8 +510,8 @@ impl CodexMessageProcessor {
             | ClientRequest::ConfigBatchWrite { .. } => {
                 warn!("Config request reached CodexMessageProcessor unexpectedly");
             }
-            ClientRequest::RequirementList { .. } => {
-                warn!("RequirementList request reached CodexMessageProcessor unexpectedly");
+            ClientRequest::ConfigRequirementsRead { .. } => {
+                warn!("ConfigRequirementsRead request reached CodexMessageProcessor unexpectedly");
             }
             ClientRequest::GetAccountRateLimits {
                 request_id,

codex-rs/app-server/src/config_api.rs

@@ -3,11 +3,11 @@ use crate::error_code::INVALID_REQUEST_ERROR_CODE;
 use codex_app_server_protocol::ConfigBatchWriteParams;
 use codex_app_server_protocol::ConfigReadParams;
 use codex_app_server_protocol::ConfigReadResponse;
+use codex_app_server_protocol::ConfigRequirementsReadResponse;
 use codex_app_server_protocol::ConfigValueWriteParams;
 use codex_app_server_protocol::ConfigWriteErrorCode;
 use codex_app_server_protocol::ConfigWriteResponse;
 use codex_app_server_protocol::JSONRPCErrorError;
-use codex_app_server_protocol::RequirementListResponse;
 use codex_app_server_protocol::Requirements;
 use codex_app_server_protocol::SandboxMode;
 use codex_core::config::ConfigService;
@@ -42,17 +42,17 @@ impl ConfigApi {
         self.service.read(params).await.map_err(map_error)
     }
 
-    pub(crate) async fn requirement_list(
+    pub(crate) async fn config_requirements_read(
         &self,
-    ) -> Result<RequirementListResponse, JSONRPCErrorError> {
+    ) -> Result<ConfigRequirementsReadResponse, JSONRPCErrorError> {
         let requirements = self
             .service
             .read_requirements()
             .await
             .map_err(map_error)?
             .map(map_requirements_toml_to_api);
 
-        Ok(RequirementListResponse { requirements })
+        Ok(ConfigRequirementsReadResponse { requirements })
     }
 
     pub(crate) async fn write_value(

codex-rs/app-server/src/message_processor.rs

@@ -158,11 +158,11 @@ impl MessageProcessor {
             ClientRequest::ConfigBatchWrite { request_id, params } => {
                 self.handle_config_batch_write(request_id, params).await;
             }
-            ClientRequest::RequirementList {
+            ClientRequest::ConfigRequirementsRead {
                 request_id,
                 params: _,
             } => {
-                self.handle_requirement_list(request_id).await;
+                self.handle_config_requirements_read(request_id).await;
             }
             other => {
                 self.codex_message_processor.process_request(other).await;
@@ -217,8 +217,8 @@ impl MessageProcessor {
         }
     }
 
-    async fn handle_requirement_list(&self, request_id: RequestId) {
-        match self.config_api.requirement_list().await {
+    async fn handle_config_requirements_read(&self, request_id: RequestId) {
+        match self.config_api.config_requirements_read().await {
             Ok(response) => self.outgoing.send_response(request_id, response).await,
             Err(error) => self.outgoing.send_error(request_id, error).await,
         }