Lightweight coding agent that runs in your terminal
Rust
Accept user input when starting idle turns (#36947)
efrazer-oai989a0b053e25
diff --git a/codex-rs/core/src/codex_thread.rs b/codex-rs/core/src/codex_thread.rsindex 0fb65079a6..3e5c3ad948 100644--- a/codex-rs/core/src/codex_thread.rs+++ b/codex-rs/core/src/codex_thread.rs@@ -4,6 +4,7 @@ use crate::elicitation::ElicitationRegistration;use crate::session::SessionIo;use crate::session::SessionSettingsUpdate;use crate::session::SteerInputError;+use crate::session::TurnInput;use crate::session::session::Session;use crate::user_message_admission::UserMessageAdmission;use codex_exec_server::SelectedCapabilityRootsStatus;@@ -93,8 +94,8 @@ pub enum TryStartTurnIfIdleRejectionReason {/// User/client-triggered mailbox work is already queued and must take/// priority over extension-initiated idle work.PendingTriggerTurn,- /// The thread is in Plan mode, where automatic idle work must not start a- /// new model turn.+ /// The thread is in Plan mode, where idle work without user input must not+ /// start a new model turn.PlanMode,/// Another turn or task is active, or the idle reservation was lost before/// the automatic turn could start.@@ -106,11 +107,11 @@ pub enum TryStartTurnIfIdleRejectionReason {#[derive(Debug)]pub struct TryStartTurnIfIdleError {reason: TryStartTurnIfIdleRejectionReason,- input: Vec<ResponseItem>,+ input: Vec<TurnInput>,}impl TryStartTurnIfIdleError {- pub(crate) fn new(reason: TryStartTurnIfIdleRejectionReason, input: Vec<ResponseItem>) -> Self {+ pub(crate) fn new(reason: TryStartTurnIfIdleRejectionReason, input: Vec<TurnInput>) -> Self {Self { reason, input }}@@ -119,9 +120,9 @@ impl TryStartTurnIfIdleError {self.reason}- /// Consumes the rejection and returns the original model-visible input+ /// Consumes the rejection and returns the original turn input/// unchanged, so callers can retry, drop, or log it explicitly.- pub fn into_input(self) -> Vec<ResponseItem> {+ pub fn into_input(self) -> Vec<TurnInput> {self.input}}@@ -371,22 +372,22 @@ impl CodexThread {self.session.inject_if_running(items).await}- /// Starts an automatic regular turn with model-visible items only when idle- /// work is allowed for this thread.+ /// Starts an automatic regular turn with response items or user input only+ /// when idle work is allowed for this thread.////// This is the required entry point for extensions that want to launch/// model-visible work from `ThreadLifecycleContributor::on_thread_idle`.- /// The call succeeds only if no user/client-triggered turn is queued, no- /// task is currently active, and the thread is not in Plan mode. Active- /// Review tasks are rejected by the active-task check because Review turns- /// are not steerable.+ /// The call succeeds only if no user/client-triggered turn is queued and no+ /// task is currently active. Work without user input is also rejected in+ /// Plan mode. Active Review tasks are rejected by the active-task check+ /// because Review turns are not steerable.////// On rejection, the returned error includes a stable reason and carries/// the original `items` unchanged so the caller can decide whether to drop/// them, retry later, or log why no automatic turn was started.pub async fn try_start_turn_if_idle(&self,- items: Vec<ResponseItem>,+ items: Vec<TurnInput>,) -> Result<(), TryStartTurnIfIdleError> {self.session.try_start_turn_if_idle(items).await}diff --git a/codex-rs/core/src/lib.rs b/codex-rs/core/src/lib.rsindex 612879cedc..f1ba9c705e 100644--- a/codex-rs/core/src/lib.rs+++ b/codex-rs/core/src/lib.rs@@ -17,6 +17,7 @@ mod responses_retry;pub(crate) mod session;pub use responses_metadata::CodexResponsesMetadata;pub use session::SteerInputError;+pub use session::TurnInput;pub use turn_metadata::detached_memory_responses_metadata;mod codex_thread;mod compact_model_fallback;diff --git a/codex-rs/core/src/session/inject.rs b/codex-rs/core/src/session/inject.rsindex e772513d00..9b73b05370 100644--- a/codex-rs/core/src/session/inject.rs+++ b/codex-rs/core/src/session/inject.rs@@ -36,27 +36,31 @@ impl Session {}}- /// Starts a regular turn with the provided items only if automatic idle work+ /// Starts a regular turn with the provided input only if automatic idle work/// is allowed for the current session state.////// This is the shared gate for extension-initiated idle work. It refuses to- /// start a turn when user/client-triggered work is queued, any task is still- /// active, or the session is currently in Plan mode. Active Review tasks are- /// covered by the active-task check because Review turns are not steerable.+ /// start a turn when user/client-triggered work is queued or any task is+ /// still active. Work without user input is also rejected in Plan mode.+ /// Active Review tasks are covered by the active-task check because Review+ /// turns are not steerable.pub(crate) async fn try_start_turn_if_idle(self: &Arc<Self>,- input: Vec<ResponseItem>,+ input: Vec<TurnInput>,) -> Result<(), TryStartTurnIfIdleError> {if input.is_empty() {return Ok(());}+ let has_user_input = input.iter().any(+ |item| matches!(item, TurnInput::UserInput { content, .. } if !content.is_empty()),+ );if self.input_queue.has_trigger_turn_mailbox_items().await {return Err(TryStartTurnIfIdleError::new(TryStartTurnIfIdleRejectionReason::PendingTriggerTurn,input,));}- if self.collaboration_mode().await.mode == ModeKind::Plan {+ if !has_user_input && self.collaboration_mode().await.mode == ModeKind::Plan {return Err(TryStartTurnIfIdleError::new(TryStartTurnIfIdleRejectionReason::PlanMode,input,@@ -87,7 +91,7 @@ impl Session {let turn_context = self.new_default_turn_with_sub_id(uuid::Uuid::new_v4().to_string()).await;- if turn_context.mode == ModeKind::Plan {+ if !has_user_input && turn_context.mode == ModeKind::Plan {self.clear_reserved_idle_turn(&turn_state).await;self.maybe_start_turn_for_pending_work().await;return Err(TryStartTurnIfIdleError::new(@@ -119,15 +123,23 @@ impl Session {));}- self.input_queue- .extend_pending_input_for_turn_state(- turn_state.as_ref(),- input.into_iter().map(TurnInput::ResponseItem).collect(),- )- .await;+ let task_input = if has_user_input {+ self.clear_connector_selection().await;+ for item in &input {+ if let TurnInput::UserInput { content, .. } = item {+ turn_context.session_telemetry.user_prompt(content);+ }+ }+ input+ } else {+ self.input_queue+ .extend_pending_input_for_turn_state(turn_state.as_ref(), input)+ .await;+ Vec::new()+ };self.start_task(turn_context,- Vec::new(),+ task_input,RegularTask::new(),MailboxParentProvenance::Ignore,)diff --git a/codex-rs/core/src/session/input_queue.rs b/codex-rs/core/src/session/input_queue.rsindex 34f6f778d7..d70dbe6306 100644--- a/codex-rs/core/src/session/input_queue.rs+++ b/codex-rs/core/src/session/input_queue.rs@@ -9,8 +9,9 @@ use std::sync::Arc;use tokio::sync::Mutex;use tokio::sync::watch;+/// Input consumed by a regular turn.#[derive(Clone, Debug, PartialEq)]-pub(crate) enum TurnInput {+pub enum TurnInput {UserInput {content: Vec<UserInput>,client_id: Option<String>,diff --git a/codex-rs/core/src/session/mod.rs b/codex-rs/core/src/session/mod.rsindex ad31042d3a..db73bdbfa4 100644--- a/codex-rs/core/src/session/mod.rs+++ b/codex-rs/core/src/session/mod.rs@@ -228,7 +228,7 @@ use self::config_lock::validate_config_lock_if_configured;use self::handlers::submission_dispatch_span;use self::handlers::submission_loop;pub(crate) use self::input_queue::InputQueueActivity;-pub(crate) use self::input_queue::TurnInput;+pub use self::input_queue::TurnInput;pub(crate) use self::input_queue::TurnInputQueue;use self::review::spawn_review_thread;use self::session::AppServerClientMetadata;diff --git a/codex-rs/core/src/session/tests.rs b/codex-rs/core/src/session/tests.rsindex 38e2d7daaf..7c6f2fce4c 100644--- a/codex-rs/core/src/session/tests.rs+++ b/codex-rs/core/src/session/tests.rs@@ -10317,7 +10317,7 @@ async fn try_start_turn_if_idle_rejects_active_turn_without_injecting() {).await;- let item = user_message("synthetic idle input");+ let item = TurnInput::ResponseItem(user_message("synthetic idle input"));let err = sess.try_start_turn_if_idle(vec![item.clone()]).await@@ -10343,7 +10343,7 @@ async fn try_start_turn_if_idle_rejects_plan_mode_without_injecting() {state.session_configuration.collaboration_mode = collaboration_mode;}- let item = user_message("synthetic idle input");+ let item = TurnInput::ResponseItem(user_message("synthetic idle input"));let err = sess.try_start_turn_if_idle(vec![item.clone()]).await@@ -10358,6 +10358,59 @@ async fn try_start_turn_if_idle_rejects_plan_mode_without_injecting() {);}+#[tokio::test]+async fn try_start_turn_if_idle_accepts_user_input_in_plan_mode() {+ let (sess, _tc, _rx) = make_session_and_context_with_rx().await;+ let mut collaboration_mode = sess.collaboration_mode().await;+ collaboration_mode.mode = ModeKind::Plan;+ {+ let mut state = sess.state.lock().await;+ state.session_configuration.collaboration_mode = collaboration_mode;+ state.merge_connector_selection(["calendar".to_string()]);+ }++ sess.try_start_turn_if_idle(vec![TurnInput::UserInput {+ content: vec![UserInput::Text {+ text: "queued user input".to_string(),+ text_elements: Vec::new(),+ }],+ client_id: Some("queued-user-message".to_string()),+ }])+ .await+ .expect("plan mode should accept user-authored idle input");++ assert!(sess.state.lock().await.get_connector_selection().is_empty());++ sess.abort_all_tasks(TurnAbortReason::Interrupted).await;+}++#[tokio::test]+async fn try_start_turn_if_idle_rejects_empty_user_input_in_plan_mode() {+ let (sess, _tc, _rx) = make_session_and_context_with_rx().await;+ let mut collaboration_mode = sess.collaboration_mode().await;+ collaboration_mode.mode = ModeKind::Plan;+ {+ let mut state = sess.state.lock().await;+ state.session_configuration.collaboration_mode = collaboration_mode;+ }++ let input = vec![+ TurnInput::UserInput {+ content: Vec::new(),+ client_id: Some("empty-queued-user-message".to_string()),+ },+ TurnInput::ResponseItem(user_message("automatic idle input")),+ ];+ let error = sess+ .try_start_turn_if_idle(input.clone())+ .await+ .expect_err("empty user input should not bypass plan mode");++ assert_eq!(TryStartTurnIfIdleRejectionReason::PlanMode, error.reason());+ assert_eq!(input, error.into_input());+ assert!(sess.active_turn.lock().await.is_none());+}+#[tokio::test]async fn try_start_turn_if_idle_rejects_pending_trigger_turn_without_injecting() {let (sess, _tc, _rx) = make_session_and_context_with_rx().await;@@ -10374,7 +10427,7 @@ async fn try_start_turn_if_idle_rejects_pending_trigger_turn_without_injecting()).await;- let item = user_message("synthetic idle input");+ let item = TurnInput::ResponseItem(user_message("synthetic idle input"));let err = sess.try_start_turn_if_idle(vec![item.clone()]).await@@ -10402,7 +10455,7 @@ async fn try_start_turn_if_idle_rejects_active_review_turn_without_injecting() {).await;- let item = user_message("synthetic idle input");+ let item = TurnInput::ResponseItem(user_message("synthetic idle input"));let err = sess.try_start_turn_if_idle(vec![item.clone()]).awaitdiff --git a/codex-rs/core/tests/suite/pending_input.rs b/codex-rs/core/tests/suite/pending_input.rsindex a5a3df2022..136996723e 100644--- a/codex-rs/core/tests/suite/pending_input.rs+++ b/codex-rs/core/tests/suite/pending_input.rs@@ -2,11 +2,15 @@ use core_test_support::test_codex::local_selections;use std::sync::Arc;use codex_core::CodexThread;+use codex_core::TurnInput;use codex_core::config::CurrentTimeReminderConfig;use codex_extension_items::ExtensionItem;use codex_extension_items::sleep::SleepItem;use codex_features::Feature;use codex_protocol::AgentPath;+use codex_protocol::config_types::CollaborationMode;+use codex_protocol::config_types::ModeKind;+use codex_protocol::config_types::Settings;use codex_protocol::items::TurnItem;use codex_protocol::models::PermissionProfile;use codex_protocol::protocol::AskForApproval;@@ -15,6 +19,7 @@ use codex_protocol::protocol::InterAgentCommunication;use codex_protocol::protocol::Op;use codex_protocol::protocol::RolloutItem;use codex_protocol::protocol::RolloutLine;+use codex_protocol::protocol::ThreadSettingsOverrides;use codex_protocol::user_input::UserInput;use core_test_support::context_snapshot;use core_test_support::context_snapshot::ContextSnapshotOptions;@@ -41,6 +46,138 @@ use serde_json::from_slice;use serde_json::json;use tokio::sync::oneshot;+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn idle_user_input_reaches_the_first_model_request() -> anyhow::Result<()> {+ assert_idle_user_input_reaches_the_first_model_request(ModeKind::Default).await+}++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn idle_user_input_reaches_the_first_model_request_in_plan_mode() -> anyhow::Result<()> {+ assert_idle_user_input_reaches_the_first_model_request(ModeKind::Plan).await+}++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn idle_response_items_include_pending_mailbox_in_first_request() -> anyhow::Result<()> {+ let server = responses::start_mock_server().await;+ let response = responses::mount_sse_once(+ &server,+ responses::sse(vec![+ ev_response_created("idle-response-items"),+ ev_completed("idle-response-items"),+ ]),+ )+ .await;+ let test = test_codex().build_with_auto_env(&server).await?;++ submit_queue_only_agent_mail(test.codex.as_ref(), "pending mailbox input").await;+ test.codex+ .try_start_turn_if_idle(vec![TurnInput::ResponseItem(responses::user_message_item(+ "automatic response item",+ ))])+ .await+ .map_err(|error| {+ anyhow::anyhow!("idle response items were rejected: {:?}", error.reason())+ })?;+ wait_for_turn_complete(test.codex.as_ref()).await;++ let request = response.single_request();+ let user_messages = request.message_input_texts("user");+ assert!(+ user_messages+ .iter()+ .any(|message| message == "automatic response item")+ );+ assert!(+ request+ .inputs_of_type("agent_message")+ .iter()+ .any(|message| {+ message["author"] == "/root/worker"+ && message["recipient"] == "/root"+ && message["content"].as_array().is_some_and(|content| {+ content.iter().any(|item| {+ item["type"] == "input_text" && item["text"] == "pending mailbox input"+ })+ })+ })+ );++ Ok(())+}++async fn assert_idle_user_input_reaches_the_first_model_request(+ mode: ModeKind,+) -> anyhow::Result<()> {+ let server = responses::start_mock_server().await;+ let response = responses::mount_sse_once(+ &server,+ responses::sse(vec![+ ev_response_created("idle-user-input"),+ ev_completed("idle-user-input"),+ ]),+ )+ .await;+ let test = test_codex().build_with_auto_env(&server).await?;++ if mode == ModeKind::Plan {+ core_test_support::submit_thread_settings(+ test.codex.as_ref(),+ ThreadSettingsOverrides {+ collaboration_mode: Some(CollaborationMode {+ mode,+ settings: Settings {+ model: test.session_configured.model.clone(),+ reasoning_effort: None,+ developer_instructions: None,+ },+ }),+ ..Default::default()+ },+ )+ .await?;+ }++ let expected_input = vec![UserInput::Text {+ text: "queued user input reaches the first request".to_string(),+ text_elements: Vec::new(),+ }];+ test.codex+ .try_start_turn_if_idle(vec![TurnInput::UserInput {+ content: expected_input.clone(),+ client_id: Some("queued-user-message".to_string()),+ }])+ .await+ .map_err(|error| anyhow::anyhow!("idle user input was rejected: {:?}", error.reason()))?;++ let user_message = core_test_support::wait_for_event_match(test.codex.as_ref(), |event| {+ let EventMsg::ItemCompleted(event) = event else {+ return None;+ };+ let TurnItem::UserMessage(item) = &event.item else {+ return None;+ };+ Some(item.clone())+ })+ .await;+ assert_eq!(+ Some("queued-user-message".to_string()),+ user_message.client_id+ );+ assert_eq!(expected_input, user_message.content);+ wait_for_turn_complete(test.codex.as_ref()).await;++ let request = response.single_request();+ assert!(+ request+ .message_input_texts("user")+ .iter()+ .any(|text| text == "queued user input reaches the first request"),+ "the first Responses request should contain the queued user message"+ );++ Ok(())+}+fn ev_message_item_done(id: &str, text: &str) -> Value {serde_json::json!({"type": "response.output_item.done",diff --git a/codex-rs/core/tests/suite/skills.rs b/codex-rs/core/tests/suite/skills.rsindex a6a4716879..84407b5b86 100644--- a/codex-rs/core/tests/suite/skills.rs+++ b/codex-rs/core/tests/suite/skills.rs@@ -2,6 +2,7 @@#![allow(clippy::unwrap_used)]use anyhow::Result;+use codex_core::TurnInput;use codex_exec_server::CreateDirectoryOptions;use codex_exec_server::ExecutorFileSystem;use codex_protocol::models::PermissionProfile;@@ -133,3 +134,68 @@ async fn user_turn_includes_skill_instructions() -> Result<()> {Ok(())}++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn idle_user_turn_includes_skill_instructions_in_the_first_request() -> Result<()> {+ skip_if_target_windows!(Ok(()), "requires native cross-OS skill paths");+ skip_if_no_network!(Ok(()));++ let server = start_mock_server().await;+ let skill_body = "queued skill body";+ let mut builder = test_codex().with_workspace_setup(move |cwd, fs| async move {+ write_repo_skill(cwd, fs, "queued-demo", "queued demo skill", skill_body).await+ });+ let test = builder.build_with_auto_env(&server).await?;+ let skill_path = test+ .config+ .cwd+ .join(".agents/skills/queued-demo/SKILL.md")+ .canonicalize()+ .unwrap_or_else(|_| test.config.cwd.join(".agents/skills/queued-demo/SKILL.md"))+ .to_path_buf();+ let mock = mount_sse_once(+ &server,+ sse(vec![+ ev_response_created("queued-skill-response"),+ ev_assistant_message("queued-skill-message", "done"),+ ev_completed("queued-skill-response"),+ ]),+ )+ .await;++ test.codex+ .try_start_turn_if_idle(vec![TurnInput::UserInput {+ content: vec![+ UserInput::Text {+ text: "please use $queued-demo".to_string(),+ text_elements: Vec::new(),+ },+ UserInput::Skill {+ name: "queued-demo".to_string(),+ path: skill_path.clone(),+ },+ ],+ client_id: Some("queued-skill-user-message".to_string()),+ }])+ .await+ .map_err(|error| anyhow::anyhow!("idle skill input was rejected: {:?}", error.reason()))?;++ core_test_support::wait_for_event(test.codex.as_ref(), |event| {+ matches!(event, codex_protocol::protocol::EventMsg::TurnComplete(_))+ })+ .await;++ let user_texts = mock.single_request().message_input_texts("user");+ let skill_path_str = skill_path.to_string_lossy();+ assert!(+ user_texts.iter().any(|text| {+ text.contains("<skill>\n<name>queued-demo</name>")+ && text.contains("<path>")+ && text.contains(skill_body)+ && text.contains(skill_path_str.as_ref())+ }),+ "expected queued skill instructions in the first request, got {user_texts:?}"+ );++ Ok(())+}diff --git a/codex-rs/ext/goal/src/runtime.rs b/codex-rs/ext/goal/src/runtime.rsindex 31b8b2eb8e..324e7a23d2 100644--- a/codex-rs/ext/goal/src/runtime.rs+++ b/codex-rs/ext/goal/src/runtime.rs@@ -4,6 +4,7 @@ use std::sync::atomic::AtomicBool;use std::sync::atomic::Ordering;use codex_core::ThreadManager;+use codex_core::TurnInput;use codex_protocol::ThreadId;use codex_protocol::models::ResponseItem;use codex_protocol::protocol::ThreadGoal;@@ -402,7 +403,10 @@ impl GoalRuntimeHandle {}let item = continuation_steering_item(&protocol_goal_from_state(goal));- if let Err(err) = thread.try_start_turn_if_idle(vec![item]).await {+ if let Err(err) = thread+ .try_start_turn_if_idle(vec![TurnInput::ResponseItem(item)])+ .await+ {let reason = err.reason();tracing::debug!(?reason,