From fb494b73d9d4c07aced072456aadfb6e1883ac18 Mon Sep 17 00:00:00 2001 From: Matthew Zeng Date: Sun, 22 Feb 2026 22:27:46 -0800 Subject: [PATCH] update --- .../app-server/src/codex_message_processor.rs | 69 +++++++++---------- codex-rs/app-server/src/message_processor.rs | 14 +++- codex-rs/core/src/thread_manager.rs | 16 +++++ 3 files changed, 61 insertions(+), 38 deletions(-) diff --git a/codex-rs/app-server/src/codex_message_processor.rs b/codex-rs/app-server/src/codex_message_processor.rs index 9e53acd636..5f06d40e17 100644 --- a/codex-rs/app-server/src/codex_message_processor.rs +++ b/codex-rs/app-server/src/codex_message_processor.rs @@ -3945,42 +3945,35 @@ impl CodexMessageProcessor { } async fn mcp_server_refresh(&self, request_id: ConnectionRequestId, _params: Option<()>) { - let config = match self.load_latest_config().await { - Ok(config) => config, - Err(error) => { - self.outgoing.send_error(request_id, error).await; - return; - } - }; + if let Err(error) = self.refresh_mcp_servers_from_latest_config().await { + self.outgoing.send_error(request_id, error).await; + return; + } - let mcp_servers = match serde_json::to_value(config.mcp_servers.get()) { - Ok(value) => value, - Err(err) => { - let error = JSONRPCErrorError { - code: INTERNAL_ERROR_CODE, - message: format!("failed to serialize MCP servers: {err}"), - data: None, - }; - self.outgoing.send_error(request_id, error).await; - return; - } - }; + let response = McpServerRefreshResponse {}; + self.outgoing.send_response(request_id, response).await; + } + + pub(crate) async fn refresh_mcp_servers_from_latest_config( + &self, + ) -> Result<(), JSONRPCErrorError> { + let config = self.load_latest_config().await?; + + let mcp_servers = + serde_json::to_value(config.mcp_servers.get()).map_err(|err| JSONRPCErrorError { + code: INTERNAL_ERROR_CODE, + message: format!("failed to serialize MCP servers: {err}"), + data: None, + })?; let mcp_oauth_credentials_store_mode = - match serde_json::to_value(config.mcp_oauth_credentials_store_mode) { - Ok(value) => value, - Err(err) => { - let error = JSONRPCErrorError { - code: INTERNAL_ERROR_CODE, - message: format!( - "failed to serialize MCP OAuth credentials store mode: {err}" - ), - data: None, - }; - self.outgoing.send_error(request_id, error).await; - return; + serde_json::to_value(config.mcp_oauth_credentials_store_mode).map_err(|err| { + JSONRPCErrorError { + code: INTERNAL_ERROR_CODE, + message: format!("failed to serialize MCP OAuth credentials store mode: {err}"), + data: None, } - }; + })?; let refresh_config = McpServerRefreshConfig { mcp_servers, @@ -3989,10 +3982,14 @@ impl CodexMessageProcessor { // Refresh requests are queued per thread; each thread rebuilds MCP connections on its next // active turn to avoid work for threads that never resume. - let thread_manager = Arc::clone(&self.thread_manager); - thread_manager.refresh_mcp_servers(refresh_config).await; - let response = McpServerRefreshResponse {}; - self.outgoing.send_response(request_id, response).await; + self.thread_manager + .refresh_mcp_servers(refresh_config) + .await; + Ok(()) + } + + pub(crate) async fn reload_user_config_for_threads(&self) { + self.thread_manager.reload_user_config().await; } async fn mcp_server_oauth_login( diff --git a/codex-rs/app-server/src/message_processor.rs b/codex-rs/app-server/src/message_processor.rs index e80e1790f8..ca36b96a6b 100644 --- a/codex-rs/app-server/src/message_processor.rs +++ b/codex-rs/app-server/src/message_processor.rs @@ -453,7 +453,12 @@ impl MessageProcessor { params: ConfigValueWriteParams, ) { match self.config_api.write_value(params).await { - Ok(response) => self.outgoing.send_response(request_id, response).await, + Ok(response) => { + self.codex_message_processor + .reload_user_config_for_threads() + .await; + self.outgoing.send_response(request_id, response).await; + } Err(error) => self.outgoing.send_error(request_id, error).await, } } @@ -464,7 +469,12 @@ impl MessageProcessor { params: ConfigBatchWriteParams, ) { match self.config_api.batch_write(params).await { - Ok(response) => self.outgoing.send_response(request_id, response).await, + Ok(response) => { + self.codex_message_processor + .reload_user_config_for_threads() + .await; + self.outgoing.send_response(request_id, response).await; + } Err(error) => self.outgoing.send_error(request_id, error).await, } } diff --git a/codex-rs/core/src/thread_manager.rs b/codex-rs/core/src/thread_manager.rs index cb7c464362..177dff6fe0 100644 --- a/codex-rs/core/src/thread_manager.rs +++ b/codex-rs/core/src/thread_manager.rs @@ -273,6 +273,22 @@ impl ThreadManager { } } + pub async fn reload_user_config(&self) { + let threads = self + .state + .threads + .read() + .await + .values() + .cloned() + .collect::>(); + for thread in threads { + if let Err(err) = thread.submit(Op::ReloadUserConfig).await { + warn!("failed to request user config reload: {err}"); + } + } + } + pub fn subscribe_thread_created(&self) -> broadcast::Receiver { self.state.thread_created_tx.subscribe() }