feat: reapply fork changes onto rust-v0.144.0

Author: Loongphy

codex-rs/Cargo.lock

@@ -484,6 +484,13 @@ pub struct GetAccountParams {
     /// themselves and call `account/login/start` with `chatgptAuthTokens`.
     #[serde(default, skip_serializing_if = "std::ops::Not::not")]
     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, skip_serializing_if = "std::ops::Not::not")]
+    pub reload_auth_from_storage: bool,
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]

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

@@ -1,3 +1,4 @@
+use crate::auth_mode::auth_mode_to_api;
 use crate::bespoke_event_handling::apply_bespoke_event_handling;
 use crate::command_exec::CommandExecManager;
 use crate::command_exec::StartCommandExecParams;
@@ -380,6 +381,7 @@ 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::CODEX_OPEN_APP_URL;
+use codex_login::AuthReloadStatus;
 use codex_login::CodexAuth;
 use codex_login::LoginSuccessPage;
 use codex_login::LoginSuccessPageBrand;
@@ -495,6 +497,81 @@ use uuid::Uuid;
 #[cfg(test)]
 use codex_app_server_protocol::ServerRequest;
 
+async fn reload_auth_from_storage_if_idle(
+    auth_manager: &Arc<AuthManager>,
+    thread_manager: &Arc<ThreadManager>,
+    config_manager: &ConfigManager,
+    outgoing: &OutgoingMessageSender,
+    thread_watch_manager: &ThreadWatchManager,
+    chatgpt_base_url: &str,
+    reason: &str,
+) {
+    if *thread_watch_manager.subscribe_running_turn_count().borrow() != 0 {
+        return;
+    }
+
+    let status = auth_manager.reload_with_status().await;
+    match handle_auth_reload_status(
+        status,
+        auth_manager,
+        thread_manager,
+        config_manager,
+        outgoing,
+        chatgpt_base_url,
+        reason,
+    )
+    .await
+    {
+        AuthReloadStatus::Reloaded { .. } => {}
+        AuthReloadStatus::Failed => {
+            warn!("failed to reload auth from storage before {reason}");
+        }
+    }
+}
+
+async fn handle_auth_reload_status(
+    status: AuthReloadStatus,
+    auth_manager: &Arc<AuthManager>,
+    thread_manager: &Arc<ThreadManager>,
+    config_manager: &ConfigManager,
+    outgoing: &OutgoingMessageSender,
+    chatgpt_base_url: &str,
+    reason: &str,
+) -> AuthReloadStatus {
+    match status {
+        AuthReloadStatus::Reloaded { changed } => {
+            if changed {
+                let invalidated_thread_count =
+                    thread_manager.invalidate_model_transport_caches().await;
+                info!(
+                    "auth reloaded from storage before {reason}; invalidated model transport caches for {invalidated_thread_count} tracked thread(s)"
+                );
+                config_manager.replace_cloud_config_bundle_loader(
+                    Arc::clone(auth_manager),
+                    chatgpt_base_url.to_string(),
+                );
+                config_manager
+                    .sync_default_client_residency_requirement()
+                    .await;
+                let auth = auth_manager.auth_cached();
+                outgoing
+                    .send_server_notification(ServerNotification::AccountUpdated(
+                        AccountUpdatedNotification {
+                            auth_mode: auth
+                                .as_ref()
+                                .map(CodexAuth::api_auth_mode)
+                                .map(auth_mode_to_api),
+                            plan_type: auth.as_ref().and_then(CodexAuth::account_plan_type),
+                        },
+                    ))
+                    .await;
+            }
+            AuthReloadStatus::Reloaded { changed }
+        }
+        AuthReloadStatus::Failed => AuthReloadStatus::Failed,
+    }
+}
+
 mod account_processor;
 mod apps_processor;
 mod catalog_processor;

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

@@ -900,6 +900,26 @@ impl AccountRequestProcessor {
     ) -> Result<GetAccountResponse, JSONRPCErrorError> {
         let do_refresh = params.refresh_token;
 
+        if params.reload_auth_from_storage {
+            let status = self.auth_manager.reload_with_status().await;
+            match handle_auth_reload_status(
+                status,
+                &self.auth_manager,
+                &self.thread_manager,
+                &self.config_manager,
+                &self.outgoing,
+                &self.config.chatgpt_base_url,
+                "account/get",
+            )
+            .await
+            {
+                AuthReloadStatus::Reloaded { .. } => {}
+                AuthReloadStatus::Failed => {
+                    return Err(internal_error("failed to reload auth from storage"));
+                }
+            }
+        }
+
         self.refresh_token_if_requested(do_refresh).await;
 
         let provider = create_model_provider(

codex-rs/app-server/src/request_processors/account_processor.rs

@@ -936,6 +936,17 @@ impl ThreadRequestProcessor {
         supports_openai_form_elicitation: bool,
         request_context: RequestContext,
     ) -> Result<(), JSONRPCErrorError> {
+        reload_auth_from_storage_if_idle(
+            &self.auth_manager,
+            &self.thread_manager,
+            &self.config_manager,
+            &self.outgoing,
+            &self.thread_watch_manager,
+            &self.config.chatgpt_base_url,
+            "thread/start",
+        )
+        .await;
+
         let ThreadStartParams {
             model,
             model_provider,
@@ -2669,6 +2680,17 @@ impl ThreadRequestProcessor {
         app_server_client_version: Option<String>,
         supports_openai_form_elicitation: bool,
     ) -> Result<(), JSONRPCErrorError> {
+        reload_auth_from_storage_if_idle(
+            &self.auth_manager,
+            &self.thread_manager,
+            &self.config_manager,
+            &self.outgoing,
+            &self.thread_watch_manager,
+            &self.config.chatgpt_base_url,
+            "thread/resume",
+        )
+        .await;
+
         if let Ok(thread_id) = ThreadId::from_string(&params.thread_id)
             && self
                 .pending_thread_unloads

codex-rs/app-server/src/request_processors/thread_processor.rs

@@ -447,6 +447,17 @@ impl TurnRequestProcessor {
         app_server_client_version: Option<String>,
         supports_openai_form_elicitation: bool,
     ) -> Result<TurnStartResponse, JSONRPCErrorError> {
+        reload_auth_from_storage_if_idle(
+            &self.auth_manager,
+            &self.thread_manager,
+            &self.config_manager,
+            &self.outgoing,
+            &self.thread_watch_manager,
+            &self.config.chatgpt_base_url,
+            "turn/start",
+        )
+        .await;
+
         let (thread_id, thread) =
             self.load_thread(&params.thread_id)
                 .await

codex-rs/app-server/src/request_processors/turn_processor.rs

@@ -765,6 +765,14 @@ pub struct Tui {
     #[serde(default)]
     pub keymap: TuiKeymap,
 
+    /// Optional synthetic user-turn prompt injected after a turn fails with
+    /// `UsageLimitExceeded`.
+    ///
+    /// When unset, Codex uses the built-in default recovery prompt.
+    /// When set to an empty string, Codex disables this automatic recovery turn.
+    #[serde(default)]
+    pub usage_limit_resume_prompt: Option<String>,
+
     /// Startup tooltip availability NUX state persisted by the TUI.
     #[serde(default)]
     pub model_availability_nux: ModelAvailabilityNuxConfig,

codex-rs/config/src/types.rs

@@ -3285,6 +3285,11 @@
           "description": "Syntax highlighting theme name (kebab-case).\n\nWhen set, overrides automatic light/dark theme detection. Use `/theme` in the TUI or see `$CODEX_HOME/themes` for custom themes.",
           "type": "string"
         },
+        "usage_limit_resume_prompt": {
+          "default": null,
+          "description": "Optional synthetic user-turn prompt injected after a turn fails with `UsageLimitExceeded`.\n\nWhen unset, Codex uses the built-in default recovery prompt. When set to an empty string, Codex disables this automatic recovery turn.",
+          "type": "string"
+        },
         "vim_mode_default": {
           "default": false,
           "description": "Start the composer in Vim mode (`Normal`) by default. Defaults to `false`.",

codex-rs/core/config.schema.json

@@ -505,6 +505,10 @@ impl ModelClient {
             .unwrap_or_else(std::sync::PoisonError::into_inner) = websocket_session;
     }
 
+    pub(crate) fn invalidate_cached_transport_state(&self) {
+        self.store_cached_websocket_session(WebsocketSession::default());
+    }
+
     pub(crate) fn force_http_fallback(
         &self,
         session_telemetry: &SessionTelemetry,

codex-rs/core/src/client.rs

@@ -211,6 +211,14 @@ impl CodexThread {
         self.codex.shutdown_and_wait().await
     }
 
+    pub(crate) fn invalidate_model_transport_cache(&self) {
+        self.codex
+            .session
+            .services
+            .model_client
+            .invalidate_cached_transport_state();
+    }
+
     /// Wait until the underlying session loop has terminated.
     pub async fn wait_until_terminated(&self) {
         self.codex.session_loop_termination.clone().await;