diff --git a/codex-rs/core/src/hook_runtime.rs b/codex-rs/core/src/hook_runtime.rs index 8f870b3f7b..a8c4db369f 100644 --- a/codex-rs/core/src/hook_runtime.rs +++ b/codex-rs/core/src/hook_runtime.rs @@ -17,6 +17,7 @@ use codex_hooks::UserPromptSubmitRequest; use codex_otel::HOOK_RUN_DURATION_METRIC; use codex_otel::HOOK_RUN_METRIC; use codex_protocol::items::TurnItem; +use codex_protocol::items::UserMessageItem; use codex_protocol::models::ResponseInputItem; use codex_protocol::models::ResponseItem; use codex_protocol::protocol::AskForApproval; @@ -35,6 +36,7 @@ use crate::context::HookAdditionalContext; use crate::event_mapping::parse_turn_item; use crate::session::session::Session; use crate::session::turn_context::TurnContext; +use crate::state::PendingInputItem; use crate::tools::hook_names::HookToolName; use crate::tools::sandboxing::PermissionRequestPayload; @@ -279,9 +281,29 @@ pub(crate) async fn run_user_prompt_submit_hooks( pub(crate) async fn inspect_input_item( sess: &Arc, turn_context: &Arc, - input_item: ResponseInputItem, - original_user_input: Option>, + input_item: PendingInputItem, ) -> InputItemHookDisposition { + let input_item = match input_item { + PendingInputItem::UserInput(content) => { + let prompt = UserMessageItem::new(&content).message(); + let response_item = ResponseItem::from(ResponseInputItem::from(content.clone())); + let user_prompt_submit_outcome = + run_user_prompt_submit_hooks(sess, turn_context, prompt).await; + if user_prompt_submit_outcome.should_stop { + return InputItemHookDisposition::Blocked { + additional_contexts: user_prompt_submit_outcome.additional_contexts, + }; + } + + return InputItemHookDisposition::Accepted(Box::new(AcceptedInputItem::UserMessage { + content, + response_item, + additional_contexts: user_prompt_submit_outcome.additional_contexts, + })); + } + PendingInputItem::ResponseInput(input_item) => input_item, + }; + let response_item = ResponseItem::from(input_item); if let Some(TurnItem::UserMessage(user_message)) = parse_turn_item(&response_item) { let user_prompt_submit_outcome = @@ -292,7 +314,7 @@ pub(crate) async fn inspect_input_item( } } else { InputItemHookDisposition::Accepted(Box::new(AcceptedInputItem::UserMessage { - content: original_user_input.unwrap_or(user_message.content), + content: user_message.content, response_item, additional_contexts: user_prompt_submit_outcome.additional_contexts, })) diff --git a/codex-rs/core/src/session/mod.rs b/codex-rs/core/src/session/mod.rs index d58e065f28..0e7c21ac73 100644 --- a/codex-rs/core/src/session/mod.rs +++ b/codex-rs/core/src/session/mod.rs @@ -281,6 +281,7 @@ use crate::skills_watcher::SkillsWatcher; use crate::skills_watcher::SkillsWatcherEvent; use crate::state::ActiveTurn; use crate::state::MailboxDeliveryPhase; +use crate::state::PendingInputItem; use crate::state::PendingRequestPermissions; use crate::state::SessionServices; use crate::state::SessionState; @@ -2997,7 +2998,7 @@ impl Session { } let mut turn_state = active_turn.turn_state.lock().await; - turn_state.push_pending_input(input.into()); + turn_state.push_pending_user_input(input); turn_state.accept_mailbox_delivery_for_current_turn(); Ok(active_turn_id.clone()) } @@ -3084,34 +3085,57 @@ impl Session { self.mailbox_rx.lock().await.has_pending() } - #[expect( - clippy::await_holding_invalid_type, - reason = "active turn checks and turn state updates must remain atomic" - )] + #[cfg(test)] pub async fn prepend_pending_input(&self, input: Vec) -> Result<(), ()> { - let mut active = self.active_turn.lock().await; - match active.as_mut() { - Some(at) => { - let mut ts = at.turn_state.lock().await; - ts.prepend_pending_input(input); - Ok(()) - } - None => Err(()), - } + self.prepend_pending_input_items( + input + .into_iter() + .map(PendingInputItem::ResponseInput) + .collect(), + ) + .await } #[expect( clippy::await_holding_invalid_type, reason = "active turn checks and turn state updates must remain atomic" )] + pub(crate) async fn prepend_pending_input_items( + &self, + input: Vec, + ) -> Result<(), ()> { + let mut active = self.active_turn.lock().await; + match active.as_mut() { + Some(at) => { + let mut ts = at.turn_state.lock().await; + ts.prepend_pending_input_items(input); + Ok(()) + } + None => Err(()), + } + } + + #[cfg(test)] pub async fn get_pending_input(&self) -> Vec { + self.take_pending_input_items() + .await + .into_iter() + .map(PendingInputItem::into_response_input_item) + .collect() + } + + #[expect( + clippy::await_holding_invalid_type, + reason = "active turn checks and turn state updates must remain atomic" + )] + pub(crate) async fn take_pending_input_items(&self) -> Vec { let (pending_input, accepts_mailbox_delivery) = { let mut active = self.active_turn.lock().await; match active.as_mut() { Some(at) => { let mut ts = at.turn_state.lock().await; ( - ts.take_pending_input(), + ts.take_pending_input_items(), ts.accepts_mailbox_delivery_for_current_turn(), ) } @@ -3127,6 +3151,7 @@ impl Session { .drain() .into_iter() .map(|mail| mail.to_response_input_item()) + .map(PendingInputItem::ResponseInput) .collect::>() }; if pending_input.is_empty() { @@ -3147,10 +3172,10 @@ impl Session { } let mut idle_pending_input = self.idle_pending_input.lock().await; - idle_pending_input.extend(items); + idle_pending_input.extend(items.into_iter().map(PendingInputItem::ResponseInput)); } - pub(crate) async fn take_queued_response_items_for_next_turn(&self) -> Vec { + pub(crate) async fn take_queued_input_items_for_next_turn(&self) -> Vec { std::mem::take(&mut *self.idle_pending_input.lock().await) } diff --git a/codex-rs/core/src/session/session.rs b/codex-rs/core/src/session/session.rs index 03849f7e07..f1a4a523a7 100644 --- a/codex-rs/core/src/session/session.rs +++ b/codex-rs/core/src/session/session.rs @@ -24,7 +24,7 @@ pub(crate) struct Session { pub(crate) active_turn: Mutex>, pub(super) mailbox: Mailbox, pub(super) mailbox_rx: Mutex, - pub(super) idle_pending_input: Mutex>, // TODO (jif) merge with mailbox! + pub(super) idle_pending_input: Mutex>, // TODO (jif) merge with mailbox! pub(crate) goal_runtime: GoalRuntimeState, pub(crate) guardian_review_session: GuardianReviewSessionManager, pub(crate) services: SessionServices, diff --git a/codex-rs/core/src/session/turn.rs b/codex-rs/core/src/session/turn.rs index 4579332247..dd06532021 100644 --- a/codex-rs/core/src/session/turn.rs +++ b/codex-rs/core/src/session/turn.rs @@ -41,6 +41,7 @@ use crate::resolve_skill_dependencies_for_turn; use crate::session::PreviousTurnSettings; use crate::session::session::Session; use crate::session::turn_context::TurnContext; +use crate::state::PendingInputItem; use crate::stream_events_utils::HandleOutputCtx; use crate::stream_events_utils::handle_non_tool_response_item; use crate::stream_events_utils::handle_output_item_done; @@ -300,8 +301,13 @@ pub(crate) async fn run_turn( return None; } if !input.is_empty() { - let input_item = ResponseInputItem::from(input.clone()); - match inspect_input_item(&sess, &turn_context, input_item, Some(input.clone())).await { + match inspect_input_item( + &sess, + &turn_context, + PendingInputItem::UserInput(input.clone()), + ) + .await + { InputItemHookDisposition::Accepted(input_item) => { record_input_item(&sess, &turn_context, *input_item).await; } @@ -366,7 +372,7 @@ pub(crate) async fn run_turn( // submitted through the UI while the model was running. Though the UI // may support this, the model might not. let pending_input = if can_drain_pending_input { - sess.get_pending_input().await + sess.take_pending_input_items().await } else { Vec::new() }; @@ -378,14 +384,7 @@ pub(crate) async fn run_turn( if !pending_input.is_empty() { let mut pending_input_iter = pending_input.into_iter(); while let Some(pending_input_item) = pending_input_iter.next() { - match inspect_input_item( - &sess, - &turn_context, - pending_input_item, - /*original_user_input*/ None, - ) - .await - { + match inspect_input_item(&sess, &turn_context, pending_input_item).await { InputItemHookDisposition::Accepted(pending_input) => { accepted_pending_input.push(*pending_input); } @@ -394,7 +393,9 @@ pub(crate) async fn run_turn( } => { let remaining_pending_input = pending_input_iter.collect::>(); if !remaining_pending_input.is_empty() { - let _ = sess.prepend_pending_input(remaining_pending_input).await; + let _ = sess + .prepend_pending_input_items(remaining_pending_input) + .await; requeued_pending_input = true; } blocked_pending_input_contexts = additional_contexts; diff --git a/codex-rs/core/src/state/mod.rs b/codex-rs/core/src/state/mod.rs index 13f3bf6c86..72529d4452 100644 --- a/codex-rs/core/src/state/mod.rs +++ b/codex-rs/core/src/state/mod.rs @@ -6,6 +6,7 @@ pub(crate) use service::SessionServices; pub(crate) use session::SessionState; pub(crate) use turn::ActiveTurn; pub(crate) use turn::MailboxDeliveryPhase; +pub(crate) use turn::PendingInputItem; pub(crate) use turn::PendingRequestPermissions; pub(crate) use turn::RunningTask; pub(crate) use turn::TaskKind; diff --git a/codex-rs/core/src/state/turn.rs b/codex-rs/core/src/state/turn.rs index 0dd0c09379..a6b519987d 100644 --- a/codex-rs/core/src/state/turn.rs +++ b/codex-rs/core/src/state/turn.rs @@ -24,6 +24,7 @@ use crate::tasks::AnySessionTask; use codex_protocol::models::AdditionalPermissionProfile; use codex_protocol::protocol::ReviewDecision; use codex_protocol::protocol::TokenUsage; +use codex_protocol::user_input::UserInput; /// Metadata about the currently running turn. pub(crate) struct ActiveTurn { @@ -84,6 +85,22 @@ pub(crate) struct RemovedTask { pub(crate) active_turn_is_empty: bool, } +#[derive(Clone, Debug, PartialEq)] +pub(crate) enum PendingInputItem { + UserInput(Vec), + ResponseInput(ResponseInputItem), +} + +impl PendingInputItem { + #[cfg(test)] + pub(crate) fn into_response_input_item(self) -> ResponseInputItem { + match self { + Self::UserInput(input) => input.into(), + Self::ResponseInput(input) => input, + } + } +} + impl ActiveTurn { pub(crate) fn add_task(&mut self, task: RunningTask) { let sub_id = task.turn_context.sub_id.clone(); @@ -113,7 +130,7 @@ pub(crate) struct TurnState { pending_user_input: HashMap>, pending_elicitations: HashMap<(String, RequestId), oneshot::Sender>, pending_dynamic_tools: HashMap>, - pending_input: Vec, + pending_input: Vec, mailbox_delivery_phase: MailboxDeliveryPhase, granted_permissions: Option, strict_auto_review_enabled: bool, @@ -219,10 +236,19 @@ impl TurnState { } pub(crate) fn push_pending_input(&mut self, input: ResponseInputItem) { + self.pending_input + .push(PendingInputItem::ResponseInput(input)); + } + + pub(crate) fn push_pending_user_input(&mut self, input: Vec) { + self.pending_input.push(PendingInputItem::UserInput(input)); + } + + pub(crate) fn push_pending_input_item(&mut self, input: PendingInputItem) { self.pending_input.push(input); } - pub(crate) fn prepend_pending_input(&mut self, mut input: Vec) { + pub(crate) fn prepend_pending_input_items(&mut self, mut input: Vec) { if input.is_empty() { return; } @@ -231,7 +257,7 @@ impl TurnState { self.pending_input = input; } - pub(crate) fn take_pending_input(&mut self) -> Vec { + pub(crate) fn take_pending_input_items(&mut self) -> Vec { if self.pending_input.is_empty() { Vec::with_capacity(0) } else { @@ -241,6 +267,14 @@ impl TurnState { } } + #[cfg(test)] + pub(crate) fn take_pending_input(&mut self) -> Vec { + self.take_pending_input_items() + .into_iter() + .map(PendingInputItem::into_response_input_item) + .collect() + } + pub(crate) fn has_pending_input(&self) -> bool { !self.pending_input.is_empty() } diff --git a/codex-rs/core/src/tasks/mod.rs b/codex-rs/core/src/tasks/mod.rs index e269adf007..5df15c33b9 100644 --- a/codex-rs/core/src/tasks/mod.rs +++ b/codex-rs/core/src/tasks/mod.rs @@ -30,6 +30,7 @@ use crate::hook_runtime::record_input_item; use crate::session::session::Session; use crate::session::turn_context::TurnContext; use crate::state::ActiveTurn; +use crate::state::PendingInputItem; use crate::state::RunningTask; use crate::state::TaskKind; use codex_analytics::TurnTokenUsageFact; @@ -41,7 +42,6 @@ use codex_otel::TURN_MEMORY_METRIC; use codex_otel::TURN_NETWORK_PROXY_METRIC; use codex_otel::TURN_TOKEN_USAGE_METRIC; use codex_otel::TURN_TOOL_CALL_METRIC; -use codex_protocol::models::ResponseInputItem; use codex_protocol::models::ResponseItem; use codex_protocol::protocol::EventMsg; use codex_protocol::protocol::RolloutItem; @@ -339,8 +339,8 @@ impl Session { { warn!("failed to apply goal runtime turn-start event: {err}"); } - let queued_response_items = self.take_queued_response_items_for_next_turn().await; - let mailbox_items = self.get_pending_input().await; + let queued_input_items = self.take_queued_input_items_for_next_turn().await; + let mailbox_items = self.take_pending_input_items().await; let turn_state = { let mut active = self.active_turn.lock().await; let turn = active.get_or_insert_with(ActiveTurn::default); @@ -350,11 +350,11 @@ impl Session { { let mut turn_state = turn_state.lock().await; turn_state.token_usage_at_turn_start = token_usage_at_turn_start; - for item in queued_response_items { - turn_state.push_pending_input(item); + for item in queued_input_items { + turn_state.push_pending_input_item(item); } for item in mailbox_items { - turn_state.push_pending_input(item); + turn_state.push_pending_input_item(item); } } @@ -562,7 +562,7 @@ impl Session { .turn_metadata_state .cancel_git_enrichment_task(); - let mut pending_input = Vec::::new(); + let mut pending_input = Vec::::new(); let mut should_clear_active_turn = false; let mut token_usage_at_turn_start = None; let mut turn_had_memory_citation = false; @@ -587,21 +587,14 @@ impl Session { }; if let Some(turn_state) = turn_state.as_ref() { let mut ts = turn_state.lock().await; - pending_input = ts.take_pending_input(); + pending_input = ts.take_pending_input_items(); turn_had_memory_citation = ts.has_memory_citation; turn_tool_calls = ts.tool_calls; token_usage_at_turn_start = Some(ts.token_usage_at_turn_start.clone()); } if !pending_input.is_empty() { for pending_input_item in pending_input { - match inspect_input_item( - self, - &turn_context, - pending_input_item, - /*original_user_input*/ None, - ) - .await - { + match inspect_input_item(self, &turn_context, pending_input_item).await { InputItemHookDisposition::Accepted(pending_input) => { record_input_item(self, &turn_context, *pending_input).await; } diff --git a/codex-rs/core/tests/suite/hooks.rs b/codex-rs/core/tests/suite/hooks.rs index 6d232afd21..23c75d0d21 100644 --- a/codex-rs/core/tests/suite/hooks.rs +++ b/codex-rs/core/tests/suite/hooks.rs @@ -45,6 +45,8 @@ use tokio::time::timeout; const FIRST_CONTINUATION_PROMPT: &str = "Retry with exactly the phrase meow meow meow."; const SECOND_CONTINUATION_PROMPT: &str = "Now tighten it to just: meow."; const BLOCKED_PROMPT_CONTEXT: &str = "Remember the blocked lighthouse note."; +const HOOK_PROMPT_XML_USER_TEXT: &str = + r#"blocked xml prompt"#; const PERMISSION_REQUEST_HOOK_MATCHER: &str = "^Bash$"; const PERMISSION_REQUEST_ALLOW_REASON: &str = "should not be used for allow"; @@ -1111,6 +1113,77 @@ async fn blocked_user_prompt_submit_persists_additional_context_for_next_turn() Ok(()) } +#[tokio::test] +async fn fresh_hook_prompt_xml_text_still_runs_user_prompt_submit() -> Result<()> { + skip_if_no_network!(Ok(())); + + let server = start_mock_server().await; + let response = mount_sse_once( + &server, + sse(vec![ + ev_response_created("resp-1"), + ev_assistant_message("msg-1", "second prompt handled"), + ev_completed("resp-1"), + ]), + ) + .await; + + let mut builder = test_codex() + .with_pre_build_hook(|home| { + if let Err(error) = write_user_prompt_submit_hook( + home, + HOOK_PROMPT_XML_USER_TEXT, + BLOCKED_PROMPT_CONTEXT, + ) { + panic!("failed to write user prompt submit hook test fixture: {error}"); + } + }) + .with_config(|config| { + config + .features + .enable(Feature::CodexHooks) + .expect("test config should allow feature update"); + }); + let test = builder.build(&server).await?; + + test.submit_turn(HOOK_PROMPT_XML_USER_TEXT).await?; + test.submit_turn("second prompt").await?; + + let request = response.single_request(); + assert!( + request + .message_input_texts("developer") + .contains(&BLOCKED_PROMPT_CONTEXT.to_string()), + "second request should include context persisted from the blocked XML-shaped prompt", + ); + assert!( + request + .message_input_texts("user") + .iter() + .all(|text| !text.contains(HOOK_PROMPT_XML_USER_TEXT)), + "blocked XML-shaped prompt should not be sent to the model", + ); + + let hook_inputs = read_user_prompt_submit_hook_inputs(test.codex_home_path())?; + assert_eq!( + hook_inputs + .iter() + .map(|input| { + input["prompt"] + .as_str() + .expect("user prompt submit hook prompt") + .to_string() + }) + .collect::>(), + vec![ + HOOK_PROMPT_XML_USER_TEXT.to_string(), + "second prompt".to_string(), + ], + ); + + Ok(()) +} + #[tokio::test] async fn blocked_queued_prompt_does_not_strand_earlier_accepted_prompt() -> Result<()> { skip_if_no_network!(Ok(())); @@ -1276,6 +1349,146 @@ async fn blocked_queued_prompt_does_not_strand_earlier_accepted_prompt() -> Resu Ok(()) } +#[tokio::test] +async fn queued_hook_prompt_xml_text_still_runs_user_prompt_submit() -> Result<()> { + skip_if_no_network!(Ok(())); + + let (gate_completed_tx, gate_completed_rx) = oneshot::channel(); + let first_chunks = vec![ + StreamingSseChunk { + gate: None, + body: sse_event(ev_response_created("resp-1")), + }, + StreamingSseChunk { + gate: None, + body: sse_event(ev_message_item_added("msg-1", "")), + }, + StreamingSseChunk { + gate: None, + body: sse_event(ev_output_text_delta("first ")), + }, + StreamingSseChunk { + gate: None, + body: sse_event(ev_message_item_done("msg-1", "first response")), + }, + StreamingSseChunk { + gate: Some(gate_completed_rx), + body: sse_event(ev_completed("resp-1")), + }, + ]; + let second_chunks = vec![StreamingSseChunk { + gate: None, + body: sse(vec![ + ev_response_created("resp-2"), + ev_assistant_message("msg-2", "accepted queued prompt handled"), + ev_completed("resp-2"), + ]), + }]; + let (server, _completions) = + start_streaming_sse_server(vec![first_chunks, second_chunks]).await; + + let mut builder = test_codex() + .with_model("gpt-5.4") + .with_pre_build_hook(|home| { + if let Err(error) = write_user_prompt_submit_hook( + home, + HOOK_PROMPT_XML_USER_TEXT, + BLOCKED_PROMPT_CONTEXT, + ) { + panic!("failed to write user prompt submit hook test fixture: {error}"); + } + }) + .with_config(|config| { + config + .features + .enable(Feature::CodexHooks) + .expect("test config should allow feature update"); + }); + let test = builder.build_with_streaming_server(&server).await?; + + test.codex + .submit(Op::UserInput { + environments: None, + items: vec![UserInput::Text { + text: "initial prompt".to_string(), + text_elements: Vec::new(), + }], + final_output_json_schema: None, + responsesapi_client_metadata: None, + }) + .await?; + + wait_for_event(&test.codex, |event| { + matches!(event, EventMsg::AgentMessageContentDelta(_)) + }) + .await; + + for text in ["accepted queued prompt", HOOK_PROMPT_XML_USER_TEXT] { + test.codex + .submit(Op::UserInput { + environments: None, + items: vec![UserInput::Text { + text: text.to_string(), + text_elements: Vec::new(), + }], + final_output_json_schema: None, + responsesapi_client_metadata: None, + }) + .await?; + } + + sleep(Duration::from_millis(100)).await; + let _ = gate_completed_tx.send(()); + + let requests = tokio::time::timeout(Duration::from_secs(30), async { + loop { + let requests = server.requests().await; + if requests.len() >= 2 { + break requests; + } + sleep(Duration::from_millis(50)).await; + } + }) + .await + .expect("second request should arrive") + .into_iter() + .collect::>(); + + sleep(Duration::from_millis(100)).await; + + assert_eq!(requests.len(), 2); + let second_user_texts = request_message_input_texts(&requests[1], "user"); + assert!( + second_user_texts.contains(&"accepted queued prompt".to_string()), + "second request should include the accepted queued prompt", + ); + assert!( + !second_user_texts.contains(&HOOK_PROMPT_XML_USER_TEXT.to_string()), + "second request should not include the blocked XML-shaped queued prompt", + ); + + let hook_inputs = read_user_prompt_submit_hook_inputs(test.codex_home_path())?; + assert_eq!( + hook_inputs + .iter() + .map(|input| { + input["prompt"] + .as_str() + .expect("queued prompt hook prompt") + .to_string() + }) + .collect::>(), + vec![ + "initial prompt".to_string(), + "accepted queued prompt".to_string(), + HOOK_PROMPT_XML_USER_TEXT.to_string(), + ], + ); + + server.shutdown().await; + Ok(()) +} + #[tokio::test] async fn permission_request_hook_allows_shell_command_without_user_approval() -> Result<()> { skip_if_no_network!(Ok(()));