Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Preserve queued TUI input semantics (#39604)

Eric Traut3434c2545b16
diff --git a/codex-rs/tui/src/app/tests.rs b/codex-rs/tui/src/app/tests.rs
index 2a053bff0a..a653a002d0 100644
--- a/codex-rs/tui/src/app/tests.rs
+++ b/codex-rs/tui/src/app/tests.rs
@@ -917,6 +917,27 @@ async fn replay_thread_snapshot_restores_draft_and_queued_input() {
let (chat_widget, _app_event_tx, _rx, mut new_op_rx) =
make_chatwidget_manual_with_sender().await;
app.chat_widget = chat_widget;
+ let outgoing_thread_id = ThreadId::new();
+ app.chat_widget.handle_thread_session(test_thread_session(
+ outgoing_thread_id,
+ test_path_buf("/tmp/outgoing-project"),
+ ));
+ app.chat_widget.handle_server_notification(
+ turn_started_notification(outgoing_thread_id, "outgoing-turn"),
+ /*replay_kind*/ None,
+ );
+ app.chat_widget
+ .apply_external_edit("outgoing queued input".to_string());
+ app.chat_widget
+ .handle_key_event(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE));
+ app.chat_widget
+ .set_queue_autosend_suppressed(/*suppressed*/ true);
+ app.chat_widget.handle_server_notification(
+ turn_completed_notification(outgoing_thread_id, "outgoing-turn", TurnStatus::Completed),
+ /*replay_kind*/ None,
+ );
+ app.chat_widget
+ .set_queue_autosend_suppressed(/*suppressed*/ false);
app.replay_thread_snapshot(snapshot, /*resume_restored_queue*/ true);
diff --git a/codex-rs/tui/src/app/thread_routing.rs b/codex-rs/tui/src/app/thread_routing.rs
index d38606c3e7..feac96ff86 100644
--- a/codex-rs/tui/src/app/thread_routing.rs
+++ b/codex-rs/tui/src/app/thread_routing.rs
@@ -1522,6 +1522,8 @@ impl App {
}
let suppress_replay_notices =
replay_filter::snapshot_has_pending_interactive_request(&snapshot);
+ self.chat_widget
+ .set_queue_autosend_suppressed(/*suppressed*/ true);
if let Some(session) = snapshot.session {
if session.reasoning_effort != Some(ReasoningEffortConfig::Ultra) {
self.chat_widget
@@ -1535,8 +1537,6 @@ impl App {
self.chat_widget.handle_thread_session(session);
}
}
- self.chat_widget
- .set_queue_autosend_suppressed(/*suppressed*/ true);
self.chat_widget.restore_thread_input_state(
snapshot.input_state,
ThreadInputStateRestoreMode {
diff --git a/codex-rs/tui/src/bottom_pane/chat_composer.rs b/codex-rs/tui/src/bottom_pane/chat_composer.rs
index a95226155d..1058a17123 100644
--- a/codex-rs/tui/src/bottom_pane/chat_composer.rs
+++ b/codex-rs/tui/src/bottom_pane/chat_composer.rs
@@ -77,6 +77,7 @@
//!
//! - Expands pending paste placeholders so element ranges align with the final text.
//! - Trims whitespace and rebases text elements accordingly.
+//! - Treats a leading `!` revealed only by paste expansion as literal model input, not shell input.
//! - Prunes local attached images so only placeholders that survive expansion are sent.
//! - Preserves remote image URLs as separate attachments even when text is empty.
//!
@@ -424,6 +425,8 @@ fn parent_owned_command_is_allowed(command: SlashCommand, args: &str) -> bool {
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum QueuedInputAction {
Plain,
+ /// Preserve model-input provenance when paste expansion reveals a leading shell sigil.
+ Literal,
ParseSlash,
RunShell,
}
@@ -3007,13 +3010,29 @@ impl ChatComposer {
}
self.draft.recent_submission_mention_bindings = original_mention_bindings.clone();
if record_history && (!text.is_empty() || !self.attachments.is_empty()) {
+ let preserve_literal_paste = self.slash_commands_enabled()
+ && text.starts_with('!')
+ && !original_input.trim_start().starts_with('!');
+ let (history_text, history_text_elements) = if preserve_literal_paste {
+ let history_text = original_input.trim().to_string();
+ let history_text_elements = Self::trim_text_elements(
+ &original_input,
+ &history_text,
+ original_text_elements,
+ );
+ (history_text, history_text_elements)
+ } else {
+ (text.clone(), text_elements.clone())
+ };
self.history.record_local_submission(HistoryEntry {
- text: text.clone(),
- text_elements: text_elements.clone(),
+ text: history_text,
+ text_elements: history_text_elements,
local_image_paths: self.attachments.local_image_paths(),
remote_image_urls: self.attachments.remote_image_urls(),
mention_bindings: original_mention_bindings,
- pending_pastes: if pending_paste_handling == PendingPasteHandling::Preserve {
+ pending_pastes: if pending_paste_handling == PendingPasteHandling::Preserve
+ || preserve_literal_paste
+ {
original_pending_pastes.clone()
} else {
Vec::new()
@@ -3091,6 +3110,10 @@ impl ChatComposer {
if let Some(pasted) = self.draft.paste_burst.flush_before_modified_input() {
self.handle_paste(pasted);
}
+ let visible_shell_command = self.is_bang_shell_command();
+ let original_input = self.current_text();
+ let original_text_elements = self.current_text_elements();
+ let original_pending_pastes = self.draft.pending_pastes.clone();
let raw_text = self.draft.textarea.text();
let defer_slash_validation = self.slash_input().should_parse_on_dequeue(raw_text);
let preserve_pending_pastes = defer_slash_validation
@@ -3115,7 +3138,20 @@ impl ChatComposer {
PendingPasteHandling::Expand
},
) {
- let action = slash_input::queued_input_action(&text, defer_slash_validation);
+ let action = if text.starts_with('!') && !visible_shell_command {
+ QueuedInputAction::Literal
+ } else {
+ slash_input::queued_input_action(&text, defer_slash_validation)
+ };
+ let (text, text_elements, pending_pastes) = if action == QueuedInputAction::Literal
+ {
+ let text = original_input.trim().to_string();
+ let text_elements =
+ Self::trim_text_elements(&original_input, &text, original_text_elements);
+ (text, text_elements, original_pending_pastes)
+ } else {
+ (text, text_elements, pending_pastes)
+ };
return (
InputResult::Queued {
text,
@@ -3152,13 +3188,19 @@ impl ChatComposer {
if let Some((text, text_elements)) =
self.prepare_submission_text(/*record_history*/ true)
{
- if should_queue {
+ if self.slash_commands_enabled()
+ && text.starts_with('!')
+ && !original_input.trim_start().starts_with('!')
+ {
+ let text = original_input.trim().to_string();
+ let text_elements =
+ Self::trim_text_elements(&original_input, &text, original_text_elements);
(
InputResult::Queued {
text,
text_elements,
- action: QueuedInputAction::Plain,
- pending_pastes: Vec::new(),
+ action: QueuedInputAction::Literal,
+ pending_pastes: original_pending_pastes,
},
true,
)
diff --git a/codex-rs/tui/src/chatwidget/input_flow.rs b/codex-rs/tui/src/chatwidget/input_flow.rs
index e947d7c780..74ce8d2aec 100644
--- a/codex-rs/tui/src/chatwidget/input_flow.rs
+++ b/codex-rs/tui/src/chatwidget/input_flow.rs
@@ -138,7 +138,10 @@ impl ChatWidget {
/// If idle and there are queued inputs, submit exactly one to start the next turn.
pub(crate) fn maybe_send_next_queued_input(&mut self) -> bool {
- if self.misalignment_policy_violation || self.input_queue.suppress_queue_autosend {
+ if !self.is_session_configured()
+ || self.misalignment_policy_violation
+ || self.input_queue.suppress_queue_autosend
+ {
return false;
}
if self.blocks_direct_input {
@@ -160,6 +163,48 @@ impl ChatWidget {
);
break;
}
+ QueuedInputAction::Literal => {
+ let QueuedUserMessage {
+ user_message,
+ pending_pastes,
+ ..
+ } = queued_message;
+ let mut restored_pending_pastes = self.bottom_pane.composer_pending_pastes();
+ let mut used_paste_placeholders = restored_pending_pastes
+ .iter()
+ .map(|(placeholder, _)| placeholder.clone())
+ .collect();
+ let (mut user_message, pending_pastes) =
+ super::user_messages::remap_colliding_paste_placeholders(
+ user_message,
+ pending_pastes,
+ &mut used_paste_placeholders,
+ );
+ if !self.current_model().trim().is_empty()
+ && (self.current_model_supports_images()
+ || (user_message.local_images.is_empty()
+ && user_message.remote_image_urls.is_empty()))
+ {
+ (user_message.text, user_message.text_elements) =
+ crate::bottom_pane::ChatComposer::expand_pending_pastes(
+ &user_message.text,
+ user_message.text_elements,
+ &pending_pastes,
+ );
+ }
+ submitted_follow_up = self
+ .submit_user_message_with_shell_escape_policy(
+ user_message,
+ ShellEscapePolicy::Disallow,
+ )
+ .is_some();
+ if !submitted_follow_up {
+ restored_pending_pastes.extend(pending_pastes);
+ self.bottom_pane
+ .set_composer_pending_pastes(restored_pending_pastes);
+ }
+ break;
+ }
QueuedInputAction::ParseSlash => {
let drain = self.submit_queued_slash_prompt(queued_message);
if drain == QueueDrain::Stop {
diff --git a/codex-rs/tui/src/chatwidget/session_flow.rs b/codex-rs/tui/src/chatwidget/session_flow.rs
index a2f3986161..a3a7b95958 100644
--- a/codex-rs/tui/src/chatwidget/session_flow.rs
+++ b/codex-rs/tui/src/chatwidget/session_flow.rs
@@ -149,7 +149,13 @@ impl ChatWidget {
self.transcript.saw_copy_source_this_turn = false;
self.refresh_skills_for_current_cwd(/*force_reload*/ true);
self.refresh_connector_mentions(/*force_refresh*/ false);
+ let initial_user_message_pending = self.initial_user_message.is_some();
self.submit_initial_user_message_if_pending();
+ if self.mcp_startup_status.is_none()
+ && (!initial_user_message_pending || self.is_user_turn_pending_or_running())
+ {
+ self.maybe_send_next_queued_input();
+ }
if display == SessionConfiguredDisplay::Normal
&& let Some(forked_from_id) = forked_from_id
{
diff --git a/codex-rs/tui/src/chatwidget/slash_dispatch.rs b/codex-rs/tui/src/chatwidget/slash_dispatch.rs
index 0c96c342e6..1b434ec247 100644
--- a/codex-rs/tui/src/chatwidget/slash_dispatch.rs
+++ b/codex-rs/tui/src/chatwidget/slash_dispatch.rs
@@ -784,7 +784,7 @@ impl ChatWidget {
if !self.apply_plan_slash_command() {
return;
}
- let user_message = self.prepared_inline_user_message(
+ let mut user_message = self.prepared_inline_user_message(
args,
text_elements,
local_images,
@@ -792,14 +792,34 @@ impl ChatWidget {
mention_bindings,
source,
);
+ if !self.is_session_configured()
+ || self.current_model().trim().is_empty()
+ || (!self.current_model_supports_images()
+ && (!user_message.local_images.is_empty()
+ || !user_message.remote_image_urls.is_empty()))
+ {
+ const PLAN_PREFIX: &str = "/plan ";
+ user_message.text.insert_str(0, PLAN_PREFIX);
+ for element in &mut user_message.text_elements {
+ element.byte_range.start += PLAN_PREFIX.len();
+ element.byte_range.end += PLAN_PREFIX.len();
+ }
+ }
if self.is_session_configured() {
self.reasoning_buffer.clear();
self.reasoning_header = None;
self.reasoning_summary_parts.clear();
self.set_status_header(String::from("Working"));
- self.submit_user_message(user_message);
+ self.submit_user_message_with_shell_escape_policy(
+ user_message,
+ ShellEscapePolicy::Disallow,
+ );
} else {
- self.queue_user_message(user_message);
+ self.queue_user_message_with_options(
+ user_message,
+ QueuedInputAction::ParseSlash,
+ Vec::new(),
+ );
}
}
SlashCommand::Goal if !trimmed.is_empty() => {
diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__hidden_shell_paste_queued_preview.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__hidden_shell_paste_queued_preview.snap
new file mode 100644
index 0000000000..6a631ff51c
--- /dev/null
+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__hidden_shell_paste_queued_preview.snap
@@ -0,0 +1,13 @@
+---
+source: tui/src/chatwidget/tests/composer_submission.rs
+expression: normalize_snapshot_paths(render_bottom_popup(&chat, 80))
+---
+• Working (0s • esc to interrupt)
+
+• Queued follow-up inputs
+ ↳ [Pasted Content 1006 chars]
+ ⌥ + ↑ edit last queued message
+
+› Ask Codex to do anything
+
+ gpt-5.6-sol default · /tmp/project
diff --git a/codex-rs/tui/src/chatwidget/tests/composer_submission.rs b/codex-rs/tui/src/chatwidget/tests/composer_submission.rs
index 8cbe80cf5d..2d62dc2824 100644
--- a/codex-rs/tui/src/chatwidget/tests/composer_submission.rs
+++ b/codex-rs/tui/src/chatwidget/tests/composer_submission.rs
@@ -9,6 +9,177 @@ use codex_protocol::permissions::NetworkSandboxPolicy;
use pretty_assertions::assert_eq;
use std::collections::VecDeque;
+fn paste_hidden_shell_payload(chat: &mut ChatWidget) -> String {
+ let payload = format!("!echo {}", "x".repeat(1000));
+ chat.handle_paste(payload.clone());
+ assert_eq!(
+ chat.bottom_pane.composer_text(),
+ format!("[Pasted Content {} chars]", payload.len())
+ );
+ payload
+}
+
+fn assert_hidden_shell_payload_is_literal(op: Result<Op, TryRecvError>, payload: String) {
+ match op {
+ Ok(Op::UserTurn { items, .. }) => assert_eq!(
+ items,
+ vec![UserInput::Text {
+ text: payload,
+ text_elements: Vec::new(),
+ }]
+ ),
+ other => panic!("expected hidden shell payload as literal input, got {other:?}"),
+ }
+}
+
+#[tokio::test]
+async fn hidden_shell_paste_submits_literal_prompt() {
+ let (mut chat, _rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.thread_id = Some(ThreadId::new());
+ let payload = paste_hidden_shell_payload(&mut chat);
+
+ chat.handle_key_event(KeyEvent::from(KeyCode::Enter));
+
+ assert_hidden_shell_payload_is_literal(op_rx.try_recv(), payload);
+}
+
+#[tokio::test]
+async fn hidden_shell_paste_recalled_from_history_submits_literal_prompt() {
+ let (mut chat, _rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.thread_id = Some(ThreadId::new());
+ let payload = paste_hidden_shell_payload(&mut chat);
+
+ chat.handle_key_event(KeyEvent::from(KeyCode::Enter));
+ assert_hidden_shell_payload_is_literal(op_rx.try_recv(), payload.clone());
+ handle_turn_started(&mut chat, "turn-1");
+ handle_turn_completed(&mut chat, "turn-1", /*duration_ms*/ None);
+ chat.handle_key_event(KeyEvent::from(KeyCode::Up));
+ chat.handle_key_event(KeyEvent::from(KeyCode::Enter));
+
+ assert_hidden_shell_payload_is_literal(op_rx.try_recv(), payload);
+}
+
+#[tokio::test]
+async fn hidden_shell_paste_queued_during_turn_submits_literal_prompt() {
+ for key in [KeyCode::Tab, KeyCode::Enter] {
+ let (mut chat, _rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.thread_id = Some(ThreadId::new());
+ handle_turn_started(&mut chat, "turn-1");
+ let payload = paste_hidden_shell_payload(&mut chat);
+
+ chat.handle_key_event(KeyEvent::new(key, KeyModifiers::NONE));
+ if key == KeyCode::Tab {
+ assert_chatwidget_snapshot!(
+ "hidden_shell_paste_queued_preview",
+ normalize_snapshot_paths(render_bottom_popup(&chat, /*width*/ 80))
+ );
+ }
+ handle_turn_completed(&mut chat, "turn-1", /*duration_ms*/ None);
+
+ assert_hidden_shell_payload_is_literal(op_rx.try_recv(), payload);
+ }
+}
+
+#[tokio::test]
+async fn hidden_shell_paste_restored_by_queue_edit_submits_literal_prompt() {
+ let (mut chat, _rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.thread_id = Some(ThreadId::new());
+ chat.chat_keymap.edit_queued_message = vec![crate::key_hint::alt(KeyCode::Up)];
+ handle_turn_started(&mut chat, "turn-1");
+ let payload = paste_hidden_shell_payload(&mut chat);
+
+ chat.handle_key_event(KeyEvent::from(KeyCode::Tab));
+ chat.handle_key_event(KeyEvent::new(KeyCode::Up, KeyModifiers::ALT));
+ chat.handle_key_event(KeyEvent::from(KeyCode::Enter));
+ handle_turn_completed(&mut chat, "turn-1", /*duration_ms*/ None);
+
+ assert_hidden_shell_payload_is_literal(op_rx.try_recv(), payload);
+}
+
+#[tokio::test]
+async fn hidden_shell_paste_restored_by_interrupt_submits_literal_prompt() {
+ let (mut chat, _rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.thread_id = Some(ThreadId::new());
+ handle_turn_started(&mut chat, "turn-1");
+ let payload = paste_hidden_shell_payload(&mut chat);
+
+ chat.handle_key_event(KeyEvent::from(KeyCode::Tab));
+ chat.on_interrupted_turn(TurnAbortReason::Interrupted);
+ chat.handle_key_event(KeyEvent::from(KeyCode::Enter));
+
+ assert_hidden_shell_payload_is_literal(op_rx.try_recv(), payload);
+}
+
+#[tokio::test]
+async fn hidden_shell_paste_restored_after_image_rejection_submits_literal_prompt() {
+ let (mut chat, _rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.thread_id = Some(ThreadId::new());
+ let current_model = chat.current_model().to_string();
+ let mut models = chat.model_catalog.try_list_models().expect("model catalog");
+ models
+ .iter_mut()
+ .find(|model| model.model == current_model)
+ .expect("current model")
+ .input_modalities
+ .retain(|modality| *modality != InputModality::Image);
+ chat.model_catalog = Arc::new(ModelCatalog::new(models));
+ chat.set_remote_image_urls(vec!["https://example.com/image.png".to_string()]);
+ let payload = paste_hidden_shell_payload(&mut chat);
+
+ chat.handle_key_event(KeyEvent::from(KeyCode::Enter));
+ chat.set_remote_image_urls(Vec::new());
+ chat.handle_key_event(KeyEvent::from(KeyCode::Enter));
+
+ assert_hidden_shell_payload_is_literal(op_rx.try_recv(), payload);
+}
+
+#[tokio::test]
+async fn hidden_shell_paste_restored_after_unavailable_model_submits_literal_prompt() {
+ let (mut chat, _rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.thread_id = Some(ThreadId::new());
+ let model = chat.current_model().to_string();
+ chat.set_model("");
+ let payload = paste_hidden_shell_payload(&mut chat);
+
+ chat.handle_key_event(KeyEvent::from(KeyCode::Enter));
+ chat.set_model(&model);
+ chat.handle_key_event(KeyEvent::from(KeyCode::Enter));
+
+ assert_hidden_shell_payload_is_literal(op_rx.try_recv(), payload);
+}
+
+#[tokio::test]
+async fn rejected_hidden_shell_paste_preserves_colliding_draft_paste() {
+ let (mut chat, _rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.thread_id = Some(ThreadId::new());
+ let model = chat.current_model().to_string();
+ handle_turn_started(&mut chat, "turn-1");
+ let payload = paste_hidden_shell_payload(&mut chat);
+ chat.handle_key_event(KeyEvent::from(KeyCode::Tab));
+ let draft_payload = format!("draft {}", "y".repeat(1000));
+ chat.handle_paste(draft_payload.clone());
+ chat.set_model("");
+
+ handle_turn_completed(&mut chat, "turn-1", /*duration_ms*/ None);
+ chat.set_model(&model);
+ chat.handle_key_event(KeyEvent::from(KeyCode::Enter));
+
+ assert_hidden_shell_payload_is_literal(op_rx.try_recv(), format!("{payload}\n{draft_payload}"));
+}
+
+#[tokio::test]
+async fn hidden_shell_paste_queued_before_session_submits_literal_prompt() {
+ let (mut chat, _rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.set_queue_submissions_until_session_configured(/*queue*/ true);
+ let payload = paste_hidden_shell_payload(&mut chat);
+
+ chat.handle_key_event(KeyEvent::from(KeyCode::Enter));
+ chat.thread_id = Some(ThreadId::new());
+ chat.maybe_send_next_queued_input();
+
+ assert_hidden_shell_payload_is_literal(op_rx.try_recv(), payload);
+}
+
#[tokio::test]
async fn parent_owned_thread_blocks_all_direct_input_entry_points() {
let (mut chat, mut rx, mut op_rx) =
diff --git a/codex-rs/tui/src/chatwidget/tests/plan_mode.rs b/codex-rs/tui/src/chatwidget/tests/plan_mode.rs
index 79a27f487f..9babdd3dab 100644
--- a/codex-rs/tui/src/chatwidget/tests/plan_mode.rs
+++ b/codex-rs/tui/src/chatwidget/tests/plan_mode.rs
@@ -7,6 +7,67 @@ fn set_composer_text(chat: &mut ChatWidget, text: &str) {
chat.refresh_plan_mode_nudge();
}
+fn paste_hidden_plan_shell_payload(chat: &mut ChatWidget) -> String {
+ let payload = format!("!echo {}", "x".repeat(1000));
+ chat.bottom_pane
+ .set_composer_text("/plan ".to_string(), Vec::new(), Vec::new());
+ chat.handle_paste(payload.clone());
+ assert_eq!(
+ chat.bottom_pane.composer_text(),
+ format!("/plan [Pasted Content {} chars]", payload.len())
+ );
+ payload
+}
+
+fn plan_test_session(thread_id: ThreadId) -> crate::session_state::ThreadSessionState {
+ crate::session_state::ThreadSessionState {
+ thread_id,
+ forked_from_id: None,
+ fork_parent_title: None,
+ thread_name: None,
+ model: "test-model".to_string(),
+ model_provider_id: "test-provider".to_string(),
+ service_tier: None,
+ approval_policy: AskForApproval::Never,
+ approvals_reviewer: ApprovalsReviewer::User,
+ permission_profile: PermissionProfile::read_only(),
+ active_permission_profile: None,
+ cwd: test_path_buf("/home/user/project").abs(),
+ runtime_workspace_roots: Vec::new(),
+ instruction_source_paths: Vec::new(),
+ reasoning_effort: Some(ReasoningEffortConfig::default()),
+ collaboration_mode: None,
+ personality: None,
+ message_history: None,
+ network_proxy: None,
+ rollout_path: None,
+ }
+}
+
+fn assert_literal_plan_prompt(chat: &ChatWidget, op: Result<Op, TryRecvError>, payload: String) {
+ match op {
+ Ok(Op::UserTurn {
+ items,
+ collaboration_mode,
+ ..
+ }) => {
+ assert_eq!(
+ items,
+ vec![UserInput::Text {
+ text: payload,
+ text_elements: Vec::new(),
+ }]
+ );
+ assert_eq!(
+ collaboration_mode.map(|mode| mode.mode),
+ Some(ModeKind::Plan)
+ );
+ }
+ other => panic!("expected literal plan prompt, got {other:?}"),
+ }
+ assert_eq!(chat.active_collaboration_mode_kind(), ModeKind::Plan);
+}
+
#[test]
fn plan_mode_nudge_matches_only_standalone_plain_text_keyword() {
assert!(contains_plan_keyword("plan"));
@@ -1475,29 +1536,7 @@ async fn plan_slash_command_with_args_submits_prompt_in_plan_mode() {
let (mut chat, _rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
chat.set_feature_enabled(Feature::CollaborationModes, /*enabled*/ true);
- let configured = crate::session_state::ThreadSessionState {
- thread_id: ThreadId::new(),
- forked_from_id: None,
- fork_parent_title: None,
- thread_name: None,
- model: "test-model".to_string(),
- model_provider_id: "test-provider".to_string(),
- service_tier: None,
- approval_policy: AskForApproval::Never,
- approvals_reviewer: ApprovalsReviewer::User,
- permission_profile: PermissionProfile::read_only(),
- active_permission_profile: None,
- cwd: test_path_buf("/home/user/project").abs(),
- runtime_workspace_roots: Vec::new(),
- instruction_source_paths: Vec::new(),
- reasoning_effort: Some(ReasoningEffortConfig::default()),
- collaboration_mode: None,
- personality: None,
- message_history: None,
- network_proxy: None,
- rollout_path: None,
- };
- chat.handle_thread_session(configured);
+ chat.handle_thread_session(plan_test_session(ThreadId::new()));
chat.bottom_pane
.set_composer_text("/plan build the plan".to_string(), Vec::new(), Vec::new());
@@ -1518,6 +1557,123 @@ async fn plan_slash_command_with_args_submits_prompt_in_plan_mode() {
assert_eq!(chat.active_collaboration_mode_kind(), ModeKind::Plan);
}
+#[tokio::test]
+async fn plan_slash_command_with_hidden_shell_paste_submits_literal_prompt() {
+ let (mut chat, _rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.thread_id = Some(ThreadId::new());
+ let payload = paste_hidden_plan_shell_payload(&mut chat);
+
+ chat.handle_key_event(KeyEvent::from(KeyCode::Enter));
+
+ assert_literal_plan_prompt(&chat, op_rx.try_recv(), payload);
+}
+
+#[tokio::test]
+async fn plan_slash_command_with_hidden_shell_paste_rejected_image_remains_literal() {
+ let (mut chat, _rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.thread_id = Some(ThreadId::new());
+ let current_model = chat.current_model().to_string();
+ let mut models = chat.model_catalog.try_list_models().expect("model catalog");
+ models
+ .iter_mut()
+ .find(|model| model.model == current_model)
+ .expect("current model")
+ .input_modalities
+ .retain(|modality| *modality != InputModality::Image);
+ chat.model_catalog = Arc::new(ModelCatalog::new(models));
+ let payload = paste_hidden_plan_shell_payload(&mut chat);
+ chat.set_remote_image_urls(vec!["https://example.com/image.png".to_string()]);
+
+ chat.handle_key_event(KeyEvent::from(KeyCode::Enter));
+ chat.set_remote_image_urls(Vec::new());
+ chat.handle_key_event(KeyEvent::from(KeyCode::Enter));
+
+ assert_literal_plan_prompt(&chat, op_rx.try_recv(), payload);
+}
+
+#[tokio::test]
+async fn plan_slash_command_with_hidden_shell_paste_unavailable_model_remains_literal() {
+ let (mut chat, _rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.thread_id = Some(ThreadId::new());
+ let model = chat.current_model().to_string();
+ chat.set_model("");
+ let payload = paste_hidden_plan_shell_payload(&mut chat);
+
+ chat.handle_key_event(KeyEvent::from(KeyCode::Enter));
+ chat.set_model(&model);
+ chat.handle_key_event(KeyEvent::from(KeyCode::Enter));
+
+ assert_literal_plan_prompt(&chat, op_rx.try_recv(), payload);
+}
+
+#[tokio::test]
+async fn plan_slash_command_with_hidden_shell_paste_queued_during_turn_submits_literal_prompt() {
+ let (mut chat, _rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.thread_id = Some(ThreadId::new());
+ handle_turn_started(&mut chat, "turn-1");
+ let payload = paste_hidden_plan_shell_payload(&mut chat);
+
+ chat.handle_key_event(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE));
+ assert_eq!(
+ chat.input_queue
+ .queued_user_messages
+ .front()
+ .unwrap()
+ .action,
+ QueuedInputAction::ParseSlash
+ );
+ handle_turn_completed(&mut chat, "turn-1", /*duration_ms*/ None);
+
+ assert_literal_plan_prompt(&chat, op_rx.try_recv(), payload);
+}
+
+#[tokio::test]
+async fn plan_slash_command_with_hidden_shell_paste_queued_before_session_submits_literal_prompt() {
+ let (mut chat, _rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ let payload = paste_hidden_plan_shell_payload(&mut chat);
+
+ chat.handle_key_event(KeyEvent::from(KeyCode::Enter));
+ chat.queue_user_message(UserMessage::from("queued follow-up"));
+ chat.finish_mcp_startup(Vec::new(), Vec::new());
+ assert_eq!(
+ chat.queued_user_message_texts(),
+ vec![format!("/plan {payload}"), "queued follow-up".to_string()]
+ );
+ chat.handle_thread_session(plan_test_session(ThreadId::new()));
+
+ assert_literal_plan_prompt(&chat, Ok(next_submit_op(&mut op_rx)), payload);
+}
+
+#[tokio::test]
+async fn rejected_initial_image_does_not_submit_later_queued_prompt() {
+ let (mut chat, _rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ let current_model = chat.current_model().to_string();
+ let mut models = chat.model_catalog.try_list_models().expect("model catalog");
+ models
+ .iter_mut()
+ .find(|model| model.model == current_model)
+ .expect("current model")
+ .input_modalities
+ .retain(|modality| *modality != InputModality::Image);
+ chat.model_catalog = Arc::new(ModelCatalog::new(models));
+ let mut initial_message = UserMessage::from("initial prompt");
+ initial_message.remote_image_urls = vec!["https://example.com/image.png".to_string()];
+ chat.initial_user_message = Some(initial_message);
+ chat.queue_user_message(UserMessage::from("queued follow-up"));
+ chat.finish_mcp_startup(Vec::new(), Vec::new());
+
+ let mut session = plan_test_session(ThreadId::new());
+ session.model = current_model;
+ chat.handle_thread_session(session);
+
+ assert_no_submit_op(&mut op_rx);
+ assert_eq!(chat.bottom_pane.composer_text(), "initial prompt");
+ assert_eq!(
+ chat.queued_user_message_texts(),
+ vec!["queued follow-up".to_string()]
+ );
+}
+
#[tokio::test]
async fn collaboration_modes_defaults_to_code_on_startup() {
let chat = make_startup_chat_with_cli_overrides(vec![(
diff --git a/codex-rs/tui/src/public_widgets/composer_input.rs b/codex-rs/tui/src/public_widgets/composer_input.rs
index 9c760b59a2..a3b2a5cac1 100644
--- a/codex-rs/tui/src/public_widgets/composer_input.rs
+++ b/codex-rs/tui/src/public_widgets/composer_input.rs
@@ -13,6 +13,7 @@ use crate::app_event::AppEvent;
use crate::app_event_sender::AppEventSender;
use crate::bottom_pane::ChatComposer;
use crate::bottom_pane::InputResult;
+use crate::bottom_pane::QueuedInputAction;
use crate::render::renderable::Renderable;
/// Action returned from feeding a key event into the ComposerInput.
@@ -62,6 +63,14 @@ impl ComposerInput {
pub fn input(&mut self, key: KeyEvent) -> ComposerAction {
let action = match self.inner.handle_key_event(key).0 {
InputResult::Submitted { text, .. } => ComposerAction::Submitted(text),
+ InputResult::Queued {
+ text,
+ text_elements,
+ action: QueuedInputAction::Literal,
+ pending_pastes,
+ } => ComposerAction::Submitted(
+ ChatComposer::expand_pending_pastes(&text, text_elements, &pending_pastes).0,
+ ),
_ => ComposerAction::None,
};
self.drain_app_events();