reapply fork changes for rust-v0.128.0

Author: Loongphy

codex-rs/Cargo.lock

@@ -2454,6 +2454,13 @@ pub struct GetAccountParams {
     /// themselves and call `account/login/start` with `chatgptAuthTokens`.
     #[serde(default)]
     pub refresh_token: bool,
+
+    /// When `true`, reloads the auth snapshot from storage before returning.
+    ///
+    /// This keeps long-lived clients in sync with `auth.json` updates without
+    /// requiring a full app-server restart.
+    #[serde(default)]
+    pub reload_auth_from_storage: bool,
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]

codex-rs/app-server-protocol/schema/json/ClientRequest.json

@@ -1618,7 +1618,7 @@ Codex supports these authentication modes. The current mode is surfaced in `acco
 
 ### API Overview
 
-- `account/read` — fetch current account info; optionally refresh tokens.
+- `account/read` — fetch current account info; optionally refresh tokens or reload auth from storage.
 - `account/login/start` — begin login (`apiKey`, `chatgpt`, `chatgptDeviceCode`).
 - `account/login/completed` (notify) — emitted when a login attempt finishes (success or error).
 - `account/login/cancel` — cancel a pending managed ChatGPT login by `loginId`.
@@ -1635,7 +1635,7 @@ Codex supports these authentication modes. The current mode is surfaced in `acco
 Request:
 
 ```json
-{ "method": "account/read", "id": 1, "params": { "refreshToken": false } }
+{ "method": "account/read", "id": 1, "params": { "refreshToken": false, "reloadAuthFromStorage": false } }
 ```
 
 Response examples:
@@ -1650,6 +1650,7 @@ Response examples:
 Field notes:
 
 - `refreshToken` (bool): set `true` to force a token refresh.
+- `reloadAuthFromStorage` (bool): set `true` to reload the current auth snapshot from storage before returning.
 - `requiresOpenaiAuth` reflects the active provider; when `false`, Codex can run without OpenAI credentials.
 
 ### 2) Log in with an API key

codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.schemas.json

@@ -304,6 +304,7 @@ use codex_feedback::FeedbackUploadOptions;
 use codex_git_utils::git_diff_to_remote;
 use codex_git_utils::resolve_root_git_project_for_trust;
 use codex_login::AuthManager;
+use codex_login::AuthReloadStatus;
 use codex_login::CLIENT_ID;
 use codex_login::CodexAuth;
 use codex_login::ServerOptions as LoginServerOptions;
@@ -325,6 +326,9 @@ use codex_memories_write::clear_memory_roots_contents;
 use codex_model_provider::ProviderAccountError;
 use codex_model_provider::create_model_provider;
 use codex_models_manager::collaboration_mode_presets::builtin_collaboration_mode_presets;
+use codex_models_manager::collaboration_mode_presets::collaboration_mode_presets_with_overrides_and_config;
+use codex_models_manager::collaboration_mode_presets::CollaborationModesConfig;
+use codex_models_manager::manager::RefreshStrategy;
 use codex_protocol::ThreadId;
 use codex_protocol::config_types::CollaborationMode;
 use codex_protocol::config_types::ForcedLoginMethod;
@@ -895,9 +899,10 @@ impl CodexMessageProcessor {
     fn normalize_turn_start_collaboration_mode(
         &self,
         mut collaboration_mode: CollaborationMode,
+        collaboration_modes_config: CollaborationModesConfig,
     ) -> CollaborationMode {
         if collaboration_mode.settings.developer_instructions.is_none()
-            && let Some(instructions) = builtin_collaboration_mode_presets()
+            && let Some(instructions) = builtin_collaboration_mode_presets(collaboration_modes_config)
                 .into_iter()
                 .find(|preset| preset.mode == Some(collaboration_mode.mode))
                 .and_then(|preset| preset.developer_instructions.flatten())
@@ -1203,11 +1208,18 @@ impl CodexMessageProcessor {
             ClientRequest::CollaborationModeList { request_id, params } => {
                 let outgoing = self.outgoing.clone();
                 let thread_manager = self.thread_manager.clone();
+                let config = self.config.clone();
                 let request_id = to_connection_request_id(request_id);
 
                 tokio::spawn(async move {
-                    Self::list_collaboration_modes(outgoing, thread_manager, request_id, params)
-                        .await;
+                    Self::list_collaboration_modes(
+                        outgoing,
+                        thread_manager,
+                        config,
+                        request_id,
+                        params,
+                    )
+                    .await;
                 });
             }
             ClientRequest::MockExperimentalMethod { request_id, params } => {
@@ -1968,6 +1980,19 @@ impl CodexMessageProcessor {
     ) -> Result<GetAccountResponse, JSONRPCErrorError> {
         let do_refresh = params.refresh_token;
 
+        if params.reload_auth_from_storage {
+            match self.auth_manager.reload_with_status().await {
+                AuthReloadStatus::Reloaded { .. } => {}
+                AuthReloadStatus::Failed => {
+                    return Err(JSONRPCErrorError {
+                        code: INTERNAL_ERROR_CODE,
+                        message: "failed to reload auth from storage".to_string(),
+                        data: None,
+                    });
+                }
+            }
+        }
+
         self.refresh_token_if_requested(do_refresh).await;
 
         let provider = create_model_provider(
@@ -5285,12 +5310,28 @@ impl CodexMessageProcessor {
     async fn list_collaboration_modes(
         outgoing: Arc<OutgoingMessageSender>,
         thread_manager: Arc<ThreadManager>,
+        config: Arc<Config>,
         request_id: ConnectionRequestId,
         params: CollaborationModeListParams,
     ) {
         let CollaborationModeListParams {} = params;
-        let items = thread_manager
-            .list_collaboration_modes()
+        let config = (*config).clone();
+        let collaboration_modes_config = CollaborationModesConfig {
+            default_mode_request_user_input: config
+                .features
+                .enabled(Feature::DefaultModeRequestUserInput),
+        };
+        let collaboration_mode_overrides = config.collaboration_mode_overrides();
+        let base_model = thread_manager
+            .get_models_manager()
+            .get_default_model(&config.model, RefreshStrategy::Offline)
+            .await;
+        let items = collaboration_mode_presets_with_overrides_and_config(
+            &base_model,
+            config.model_reasoning_effort,
+            collaboration_mode_overrides.as_ref(),
+            collaboration_modes_config,
+        )
             .into_iter()
             .map(Into::into)
             .collect();
@@ -6558,9 +6599,14 @@ impl CodexMessageProcessor {
                 self.track_error_response(&request_id, error, /*error_type*/ None);
             })?;
 
+            let collaboration_modes_config = CollaborationModesConfig {
+                default_mode_request_user_input: self.config
+                    .features
+                    .enabled(Feature::DefaultModeRequestUserInput),
+            };
             let collaboration_mode = params
                 .collaboration_mode
-                .map(|mode| self.normalize_turn_start_collaboration_mode(mode));
+                .map(|mode| self.normalize_turn_start_collaboration_mode(mode, collaboration_modes_config));
             let environments: Option<Vec<TurnEnvironmentSelection>> =
                 params.environments.map(|environments| {
                     environments

codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.v2.schemas.json

@@ -11,6 +11,7 @@ use crate::types::AnalyticsConfigToml;
 use crate::types::ApprovalsReviewer;
 use crate::types::AppsConfigToml;
 use crate::types::AuthCredentialsStoreMode;
+use crate::types::CollaborationModeOverrides;
 use crate::types::FeedbackConfigToml;
 use crate::types::History;
 use crate::types::MarketplaceConfig;
@@ -259,6 +260,9 @@ pub struct ConfigToml {
     /// Defaults to `false`.
     pub show_raw_agent_reasoning: Option<bool>,
 
+    /// Optional overrides for collaboration mode presets.
+    pub collaboration_modes: Option<CollaborationModeOverrides>,
+
     pub model_reasoning_effort: Option<ReasoningEffort>,
     pub plan_mode_reasoning_effort: Option<ReasoningEffort>,
     pub model_reasoning_summary: Option<ReasoningSummary>,