Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Allow empty input to start a turn (#38084)

Rasmus Rygaard52d92184240b
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<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
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("<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();