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

@@ -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<String>,
         state: PendingUserMessageAdmissionState,
     ) -> Result<UserMessageAdmission, UserMessageAdmissionError> {
-        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

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("<environment_context>"));
+}
+
+#[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();