fix(core): add timeout to compaction operations to prevent UI hangs

Both inline and remote compaction could hang indefinitely when the
model API was unresponsive, leaving the TUI stuck on "Automatically
compacting context" with no way to recover.

Wrap `drain_to_completed()` and `compact_conversation_history()` with
a 120-second `tokio::time::timeout`. On timeout the existing
`CodexErr::Timeout` variant is returned, which `is_retryable()` treats
as retryable, so the existing retry-with-backoff loop handles it
gracefully instead of blocking the UI forever.

Closes openai#14472

Author: Acture

codex-rs/core/src/compact.rs

@@ -1,4 +1,5 @@
 use std::sync::Arc;
+use std::time::Duration;
 
 use crate::ModelProviderInfo;
 use crate::Prompt;
@@ -26,8 +27,14 @@ use codex_utils_output_truncation::TruncationPolicy;
 use codex_utils_output_truncation::approx_token_count;
 use codex_utils_output_truncation::truncate_text;
 use futures::prelude::*;
+use tokio::time::timeout;
 use tracing::error;
 
+/// Maximum time to wait for a compaction operation to complete before
+/// treating it as a timeout. This prevents the UI from hanging
+/// indefinitely when the model API is unresponsive.
+pub(crate) const COMPACTION_TIMEOUT: Duration = Duration::from_secs(120);
+
 pub const SUMMARIZATION_PROMPT: &str = include_str!("../templates/compact/prompt.md");
 pub const SUMMARY_PREFIX: &str = include_str!("../templates/compact/summary_prefix.md");
 const COMPACT_USER_MESSAGE_MAX_TOKENS: usize = 20_000;
@@ -126,14 +133,21 @@ async fn run_compact_task_inner(
             ..Default::default()
         };
         let turn_metadata_header = turn_context.turn_metadata_state.current_header_value();
-        let attempt_result = drain_to_completed(
-            &sess,
-            turn_context.as_ref(),
-            &mut client_session,
-            turn_metadata_header.as_deref(),
-            &prompt,
+        let attempt_result = match timeout(
+            COMPACTION_TIMEOUT,
+            drain_to_completed(
+                &sess,
+                turn_context.as_ref(),
+                &mut client_session,
+                turn_metadata_header.as_deref(),
+                &prompt,
+            ),
         )
-        .await;
+        .await
+        {
+            Ok(inner) => inner,
+            Err(_elapsed) => Err(CodexErr::Timeout),
+        };
 
         match attempt_result {
             Ok(()) => {

codex-rs/core/src/compact_remote.rs

@@ -21,10 +21,13 @@ use codex_protocol::items::TurnItem;
 use codex_protocol::models::BaseInstructions;
 use codex_protocol::models::ResponseItem;
 use futures::TryFutureExt;
+use tokio::time::timeout;
 use tokio_util::sync::CancellationToken;
 use tracing::error;
 use tracing::info;
 
+use crate::compact::COMPACTION_TIMEOUT;
+
 pub(crate) async fn run_inline_remote_auto_compact_task(
     sess: Arc<Session>,
     turn_context: Arc<TurnContext>,
@@ -114,29 +117,35 @@ async fn run_remote_compact_task_inner_impl(
         output_schema: None,
     };
 
-    let mut new_history = sess
-        .services
-        .model_client
-        .compact_conversation_history(
-            &prompt,
-            &turn_context.model_info,
-            turn_context.reasoning_effort,
-            turn_context.reasoning_summary,
-            &turn_context.session_telemetry,
-        )
-        .or_else(|err| async {
-            let total_usage_breakdown = sess.get_total_token_usage_breakdown().await;
-            let compact_request_log_data =
-                build_compact_request_log_data(&prompt.input, &prompt.base_instructions.text);
-            log_remote_compact_failure(
-                turn_context,
-                &compact_request_log_data,
-                total_usage_breakdown,
-                &err,
-            );
-            Err(err)
-        })
-        .await?;
+    let mut new_history = match timeout(
+        COMPACTION_TIMEOUT,
+        sess.services
+            .model_client
+            .compact_conversation_history(
+                &prompt,
+                &turn_context.model_info,
+                turn_context.reasoning_effort,
+                turn_context.reasoning_summary,
+                &turn_context.session_telemetry,
+            )
+            .or_else(|err| async {
+                let total_usage_breakdown = sess.get_total_token_usage_breakdown().await;
+                let compact_request_log_data =
+                    build_compact_request_log_data(&prompt.input, &prompt.base_instructions.text);
+                log_remote_compact_failure(
+                    turn_context,
+                    &compact_request_log_data,
+                    total_usage_breakdown,
+                    &err,
+                );
+                Err(err)
+            }),
+    )
+    .await
+    {
+        Ok(result) => result?,
+        Err(_elapsed) => return Err(CodexErr::Timeout),
+    };
     new_history = process_compacted_history(
         sess.as_ref(),
         turn_context.as_ref(),

codex-rs/core/src/compact_tests.rs

@@ -559,3 +559,28 @@ fn insert_initial_context_before_last_real_user_or_summary_keeps_compaction_last
     ];
     assert_eq!(refreshed, expected);
 }
+
+#[tokio::test]
+async fn compaction_timeout_produces_retryable_timeout_error() {
+    use std::time::Duration;
+    use tokio::time::timeout;
+
+    // Simulate a compaction call that hangs indefinitely.
+    let hanging_future = futures::future::pending::<CodexResult<()>>();
+
+    let result = match timeout(Duration::from_millis(50), hanging_future).await {
+        Ok(inner) => inner,
+        Err(_elapsed) => Err(CodexErr::Timeout),
+    };
+
+    assert!(result.is_err());
+    let err = result.unwrap_err();
+    assert!(
+        matches!(err, CodexErr::Timeout),
+        "expected CodexErr::Timeout, got {err:?}"
+    );
+    assert!(
+        err.is_retryable(),
+        "Timeout should be retryable so the compact retry loop can handle it"
+    );
+}