From 52d92184240bd0946e3e15b3a568f8014a9e0b97 Mon Sep 17 00:00:00 2001 From: Rasmus Rygaard Date: Tue, 11 Aug 2026 22:56:54 +0000 Subject: [PATCH] Allow empty input to start a turn (#38084) ## What changed - Permit immediate user-message admission to start a turn when `Op::UserInput` has no items. The turn can proceed with its generated environment context and does not emit a user-message item. - Continue rejecting empty input for persisted admission, where there is no user message to persist. ## Testing - Cover successful empty-input turn admission and completion. - Cover prompt rejection of empty persisted admission. GitOrigin-RevId: d534cf0e228e3bc77f45fe6d9bd25c9073216fbd --- codex-rs/core/src/codex_thread.rs | 16 ++-- .../tests/suite/user_message_admission.rs | 93 +++++++++++++++++++ 2 files changed, 101 insertions(+), 8 deletions(-) diff --git a/codex-rs/core/src/codex_thread.rs b/codex-rs/core/src/codex_thread.rs index 0c3db6c299..310587fad2 100644 --- a/codex-rs/core/src/codex_thread.rs +++ b/codex-rs/core/src/codex_thread.rs @@ -356,6 +356,13 @@ impl CodexThread { ), )); } + if matches!(&op, Op::UserInput { items, .. } if items.is_empty()) { + return Err(UserMessageAdmissionError::Admission( + CodexErr::InvalidRequest( + "user message admission requires nonempty user input".to_string(), + ), + )); + } self.submit_user_input_and_wait_for_admission_inner( op, trace, @@ -372,18 +379,11 @@ impl CodexThread { client_user_message_id: Option, state: PendingUserMessageAdmissionState, ) -> Result { - let Op::UserInput { items, .. } = &op else { + let Op::UserInput { .. } = &op else { return Err(UserMessageAdmissionError::Admission( CodexErr::InvalidRequest("user message admission requires user input".to_string()), )); }; - if items.is_empty() { - return Err(UserMessageAdmissionError::Admission( - CodexErr::InvalidRequest( - "user message admission requires nonempty user input".to_string(), - ), - )); - } self.session .services .agent_control diff --git a/codex-rs/core/tests/suite/user_message_admission.rs b/codex-rs/core/tests/suite/user_message_admission.rs index e89c9ba6fb..355a0cef7b 100644 --- a/codex-rs/core/tests/suite/user_message_admission.rs +++ b/codex-rs/core/tests/suite/user_message_admission.rs @@ -1,4 +1,5 @@ use codex_core::UserMessageAdmission; +use codex_core::UserMessageAdmissionError; use codex_core::config::Constrained; use codex_history::RolloutItem; use codex_history::RolloutLine; @@ -39,6 +40,98 @@ fn user_input(text: &str) -> Op { } } +fn empty_user_input() -> Op { + Op::UserInput { + items: Vec::new(), + final_output_json_schema: None, + responsesapi_client_metadata: None, + additional_context: Default::default(), + thread_settings: Default::default(), + } +} + +#[tokio::test] +async fn user_message_admission_starts_turn_for_empty_input() { + let server = responses::start_mock_server().await; + let response_mock = responses::mount_sse_once( + &server, + responses::sse(vec![ev_response_created("resp-1"), ev_completed("resp-1")]), + ) + .await; + let test = test_codex() + .with_model("gpt-5.4") + .build_with_auto_env(&server) + .await + .expect("build empty user-message admission session"); + + let admission = test + .codex + .submit_user_input_and_wait_for_admission( + empty_user_input(), + /*trace*/ None, + Some("clock-wake".to_string()), + ) + .await + .expect("empty user input should start a turn"); + assert!(matches!(admission, UserMessageAdmission::Started { .. })); + + loop { + let event = timeout(Duration::from_secs(10), test.codex.next_event()) + .await + .expect("empty-input turn should finish promptly") + .expect("empty-input turn event stream should remain available"); + match event.msg { + EventMsg::ItemStarted(event) => { + assert!(!matches!(event.item, TurnItem::UserMessage(_))); + } + EventMsg::ItemCompleted(event) => { + assert!(!matches!(event.item, TurnItem::UserMessage(_))); + } + EventMsg::Error(error) => panic!("empty-input turn failed: {error:?}"), + EventMsg::StreamError(error) => { + panic!("empty-input turn stream failed: {error:?}") + } + EventMsg::TurnComplete(_) => break, + _ => {} + } + } + + let user_input_groups = response_mock + .single_request() + .message_input_text_groups("user"); + assert_eq!(user_input_groups.len(), 1); + assert_eq!(user_input_groups[0].len(), 1); + assert!(user_input_groups[0][0].starts_with("")); +} + +#[tokio::test] +async fn persisted_user_message_admission_rejects_empty_input() { + let server = responses::start_mock_server().await; + let test = test_codex() + .with_model("gpt-5.4") + .build_with_auto_env(&server) + .await + .expect("build persisted user-message admission session"); + + let error = timeout( + Duration::from_secs(5), + test.codex + .submit_user_input_and_wait_for_persisted_admission( + empty_user_input(), + /*trace*/ None, + Some("empty-client-message".to_string()), + ), + ) + .await + .expect("empty persisted input should be rejected promptly") + .expect_err("empty input cannot produce a persisted user message"); + assert!(matches!( + error, + UserMessageAdmissionError::Admission(ref error) + if matches!(error.details(), CodexErrorDetails::InvalidRequest(_)) + )); +} + #[tokio::test(flavor = "multi_thread", worker_threads = 2)] async fn default_turn_start_persists_developer_and_user_input_before_model_request() { let (release_response, response_gate) = oneshot::channel();