From 72504f1d9c6eb17086d86ef1fb0d17676812461b Mon Sep 17 00:00:00 2001 From: aibrahim-oai Date: Sat, 12 Jul 2025 15:32:00 -0700 Subject: [PATCH 1/7] Add paste summarization to Codex TUI (#1549) ## Summary - introduce `Paste` event to avoid per-character paste handling - collapse large pasted blocks to `[Pasted Content X lines]` - store the real text so submission still includes it - wire paste handling through `App`, `ChatWidget`, `BottomPane`, and `ChatComposer` ## Testing - `cargo test -p codex-tui` ------ https://chatgpt.com/codex/tasks/task_i_6871e24abf80832184d1f3ca0c61a5ee https://github.com/user-attachments/assets/eda7412f-da30-4474-9f7c-96b49d48fbf8 --- codex-rs/Cargo.lock | 30 ++ codex-rs/tui/Cargo.toml | 1 + codex-rs/tui/src/app.rs | 26 +- codex-rs/tui/src/app_event.rs | 3 + codex-rs/tui/src/bottom_pane/chat_composer.rs | 413 +++++++++++++++++- codex-rs/tui/src/bottom_pane/mod.rs | 9 + ...mposer__tests__backspace_after_pastes.snap | 14 + ...tom_pane__chat_composer__tests__empty.snap | 14 + ...tom_pane__chat_composer__tests__large.snap | 14 + ...chat_composer__tests__multiple_pastes.snap | 14 + ...tom_pane__chat_composer__tests__small.snap | 14 + codex-rs/tui/src/chatwidget.rs | 6 + 12 files changed, 542 insertions(+), 16 deletions(-) create mode 100644 codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__backspace_after_pastes.snap create mode 100644 codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__empty.snap create mode 100644 codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__large.snap create mode 100644 codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__multiple_pastes.snap create mode 100644 codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__small.snap diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lock index 2909c2c594..3de3e78198 100644 --- a/codex-rs/Cargo.lock +++ b/codex-rs/Cargo.lock @@ -787,6 +787,7 @@ dependencies = [ "color-eyre", "crossterm", "image", + "insta", "lazy_static", "mcp-types", "path-clean", @@ -871,6 +872,18 @@ dependencies = [ "crossbeam-utils", ] +[[package]] +name = "console" +version = "0.15.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "054ccb5b10f9f2cbf51eb355ca1d05c2d279ce1804688d0db74b4733a5aeafd8" +dependencies = [ + "encode_unicode", + "libc", + "once_cell", + "windows-sys 0.59.0", +] + [[package]] name = "convert_case" version = "0.6.0" @@ -1230,6 +1243,12 @@ dependencies = [ "log", ] +[[package]] +name = "encode_unicode" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0" + [[package]] name = "encoding_rs" version = "0.8.35" @@ -2110,6 +2129,17 @@ version = "2.0.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f4c7245a08504955605670dbf141fceab975f15ca21570696aebe9d2e71576bd" +[[package]] +name = "insta" +version = "1.43.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "154934ea70c58054b556dd430b99a98c2a7ff5309ac9891597e339b5c28f4371" +dependencies = [ + "console", + "once_cell", + "similar", +] + [[package]] name = "instability" version = "0.3.7" diff --git a/codex-rs/tui/Cargo.toml b/codex-rs/tui/Cargo.toml index 151222a1d3..74aedfa353 100644 --- a/codex-rs/tui/Cargo.toml +++ b/codex-rs/tui/Cargo.toml @@ -61,4 +61,5 @@ unicode-segmentation = "1.12.0" uuid = "1" [dev-dependencies] +insta = "1.43.1" pretty_assertions = "1" diff --git a/codex-rs/tui/src/app.rs b/codex-rs/tui/src/app.rs index 4b8b9b7812..e1dde8332d 100644 --- a/codex-rs/tui/src/app.rs +++ b/codex-rs/tui/src/app.rs @@ -98,21 +98,7 @@ impl<'a> App<'a> { scroll_event_helper.scroll_down(); } crossterm::event::Event::Paste(pasted) => { - use crossterm::event::KeyModifiers; - - for ch in pasted.chars() { - let key_event = match ch { - '\n' | '\r' => { - // Represent newline as so that the bottom - // pane treats it as a literal newline instead of a submit - // action (submission is only triggered on Enter *without* - // any modifiers). - KeyEvent::new(KeyCode::Enter, KeyModifiers::SHIFT) - } - _ => KeyEvent::new(KeyCode::Char(ch), KeyModifiers::empty()), - }; - app_event_tx.send(AppEvent::KeyEvent(key_event)); - } + app_event_tx.send(AppEvent::Paste(pasted)); } _ => { // Ignore any other events. @@ -223,6 +209,9 @@ impl<'a> App<'a> { AppEvent::Scroll(scroll_delta) => { self.dispatch_scroll_event(scroll_delta); } + AppEvent::Paste(text) => { + self.dispatch_paste_event(text); + } AppEvent::CodexEvent(event) => { self.dispatch_codex_event(event); } @@ -343,6 +332,13 @@ impl<'a> App<'a> { } } + fn dispatch_paste_event(&mut self, pasted: String) { + match &mut self.app_state { + AppState::Chat { widget } => widget.handle_paste(pasted), + AppState::Login { .. } | AppState::GitWarning { .. } => {} + } + } + fn dispatch_scroll_event(&mut self, scroll_delta: i32) { match &mut self.app_state { AppState::Chat { widget } => widget.handle_scroll_delta(scroll_delta), diff --git a/codex-rs/tui/src/app_event.rs b/codex-rs/tui/src/app_event.rs index dd89b85331..fd6b2479ee 100644 --- a/codex-rs/tui/src/app_event.rs +++ b/codex-rs/tui/src/app_event.rs @@ -12,6 +12,9 @@ pub(crate) enum AppEvent { KeyEvent(KeyEvent), + /// Text pasted from the terminal clipboard. + Paste(String), + /// Scroll event with a value representing the "scroll delta" as the net /// scroll up/down events within a short time window. Scroll(i32), diff --git a/codex-rs/tui/src/bottom_pane/chat_composer.rs b/codex-rs/tui/src/bottom_pane/chat_composer.rs index 29bf74c810..e89187d165 100644 --- a/codex-rs/tui/src/bottom_pane/chat_composer.rs +++ b/codex-rs/tui/src/bottom_pane/chat_composer.rs @@ -28,6 +28,9 @@ const MIN_TEXTAREA_ROWS: usize = 1; const BORDER_LINES: u16 = 2; const BASE_PLACEHOLDER_TEXT: &str = "send a message"; +/// If the pasted content exceeds this number of characters, replace it with a +/// placeholder in the UI. +const LARGE_PASTE_CHAR_THRESHOLD: usize = 1000; /// Result returned when the user interacts with the text area. pub enum InputResult { @@ -43,6 +46,7 @@ pub(crate) struct ChatComposer<'a> { ctrl_c_quit_hint: bool, dismissed_file_popup_token: Option, current_file_query: Option, + pending_pastes: Vec<(String, String)>, } /// Popup state – at most one can be visible at any time. @@ -66,6 +70,7 @@ impl ChatComposer<'_> { ctrl_c_quit_hint: false, dismissed_file_popup_token: None, current_file_query: None, + pending_pastes: Vec::new(), }; this.update_border(has_input_focus); this @@ -126,6 +131,20 @@ impl ChatComposer<'_> { self.update_border(has_focus); } + pub fn handle_paste(&mut self, pasted: String) -> bool { + let char_count = pasted.chars().count(); + if char_count > LARGE_PASTE_CHAR_THRESHOLD { + let placeholder = format!("[Pasted Content {char_count} chars]"); + self.textarea.insert_str(&placeholder); + self.pending_pastes.push((placeholder, pasted)); + } else { + self.textarea.insert_str(&pasted); + } + self.sync_command_popup(); + self.sync_file_search_popup(); + true + } + /// Integrate results from an asynchronous file search. pub(crate) fn on_file_search_result(&mut self, query: String, matches: Vec) { // Only apply if user is still editing a token starting with `query`. @@ -414,10 +433,18 @@ impl ChatComposer<'_> { alt: false, ctrl: false, } => { - let text = self.textarea.lines().join("\n"); + let mut text = self.textarea.lines().join("\n"); self.textarea.select_all(); self.textarea.cut(); + // Replace all pending pastes in the text + for (placeholder, actual) in &self.pending_pastes { + if text.contains(placeholder) { + text = text.replace(placeholder, actual); + } + } + self.pending_pastes.clear(); + if text.is_empty() { (InputResult::None, true) } else { @@ -443,10 +470,71 @@ impl ChatComposer<'_> { /// Handle generic Input events that modify the textarea content. fn handle_input_basic(&mut self, input: Input) -> (InputResult, bool) { + // Special handling for backspace on placeholders + if let Input { + key: Key::Backspace, + .. + } = input + { + if self.try_remove_placeholder_at_cursor() { + return (InputResult::None, true); + } + } + + // Normal input handling self.textarea.input(input); + let text_after = self.textarea.lines().join("\n"); + + // Check if any placeholders were removed and remove their corresponding pending pastes + self.pending_pastes + .retain(|(placeholder, _)| text_after.contains(placeholder)); + (InputResult::None, true) } + /// Attempts to remove a placeholder if the cursor is at the end of one. + /// Returns true if a placeholder was removed. + fn try_remove_placeholder_at_cursor(&mut self) -> bool { + let (row, col) = self.textarea.cursor(); + let line = self + .textarea + .lines() + .get(row) + .map(|s| s.as_str()) + .unwrap_or(""); + + // Find any placeholder that ends at the cursor position + let placeholder_to_remove = self.pending_pastes.iter().find_map(|(ph, _)| { + if col < ph.len() { + return None; + } + let potential_ph_start = col - ph.len(); + if line[potential_ph_start..col] == *ph { + Some(ph.clone()) + } else { + None + } + }); + + if let Some(placeholder) = placeholder_to_remove { + // Remove the entire placeholder from the text + let placeholder_len = placeholder.len(); + for _ in 0..placeholder_len { + self.textarea.input(Input { + key: Key::Backspace, + ctrl: false, + alt: false, + shift: false, + }); + } + // Remove from pending pastes + self.pending_pastes.retain(|(ph, _)| ph != &placeholder); + true + } else { + false + } + } + /// Synchronize `self.command_popup` with the current text in the /// textarea. This must be called after every modification that can change /// the text so the popup is shown/updated/hidden as appropriate. @@ -624,7 +712,10 @@ impl WidgetRef for &ChatComposer<'_> { #[cfg(test)] mod tests { + use crate::bottom_pane::AppEventSender; use crate::bottom_pane::ChatComposer; + use crate::bottom_pane::InputResult; + use crate::bottom_pane::chat_composer::LARGE_PASTE_CHAR_THRESHOLD; use tui_textarea::TextArea; #[test] @@ -770,4 +861,324 @@ mod tests { ); } } + + #[test] + fn handle_paste_small_inserts_text() { + use crossterm::event::KeyCode; + use crossterm::event::KeyEvent; + use crossterm::event::KeyModifiers; + + let (tx, _rx) = std::sync::mpsc::channel(); + let sender = AppEventSender::new(tx); + let mut composer = ChatComposer::new(true, sender); + + let needs_redraw = composer.handle_paste("hello".to_string()); + assert!(needs_redraw); + assert_eq!(composer.textarea.lines(), ["hello"]); + assert!(composer.pending_pastes.is_empty()); + + let (result, _) = + composer.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)); + match result { + InputResult::Submitted(text) => assert_eq!(text, "hello"), + _ => panic!("expected Submitted"), + } + } + + #[test] + fn handle_paste_large_uses_placeholder_and_replaces_on_submit() { + use crossterm::event::KeyCode; + use crossterm::event::KeyEvent; + use crossterm::event::KeyModifiers; + + let (tx, _rx) = std::sync::mpsc::channel(); + let sender = AppEventSender::new(tx); + let mut composer = ChatComposer::new(true, sender); + + let large = "x".repeat(LARGE_PASTE_CHAR_THRESHOLD + 10); + let needs_redraw = composer.handle_paste(large.clone()); + assert!(needs_redraw); + let placeholder = format!("[Pasted Content {} chars]", large.chars().count()); + assert_eq!(composer.textarea.lines(), [placeholder.as_str()]); + assert_eq!(composer.pending_pastes.len(), 1); + assert_eq!(composer.pending_pastes[0].0, placeholder); + assert_eq!(composer.pending_pastes[0].1, large); + + let (result, _) = + composer.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)); + match result { + InputResult::Submitted(text) => assert_eq!(text, large), + _ => panic!("expected Submitted"), + } + assert!(composer.pending_pastes.is_empty()); + } + + #[test] + fn edit_clears_pending_paste() { + use crossterm::event::KeyCode; + use crossterm::event::KeyEvent; + use crossterm::event::KeyModifiers; + + let large = "y".repeat(LARGE_PASTE_CHAR_THRESHOLD + 1); + let (tx, _rx) = std::sync::mpsc::channel(); + let sender = AppEventSender::new(tx); + let mut composer = ChatComposer::new(true, sender); + + composer.handle_paste(large); + assert_eq!(composer.pending_pastes.len(), 1); + + // Any edit that removes the placeholder should clear pending_paste + composer.handle_key_event(KeyEvent::new(KeyCode::Backspace, KeyModifiers::NONE)); + assert!(composer.pending_pastes.is_empty()); + } + + #[test] + fn ui_snapshots() { + use crossterm::event::KeyCode; + use crossterm::event::KeyEvent; + use crossterm::event::KeyModifiers; + use insta::assert_snapshot; + use ratatui::Terminal; + use ratatui::backend::TestBackend; + + let (tx, _rx) = std::sync::mpsc::channel(); + let sender = AppEventSender::new(tx); + let mut terminal = match Terminal::new(TestBackend::new(100, 10)) { + Ok(t) => t, + Err(e) => panic!("Failed to create terminal: {e}"), + }; + + let test_cases = vec![ + ("empty", None), + ("small", Some("short".to_string())), + ("large", Some("z".repeat(LARGE_PASTE_CHAR_THRESHOLD + 5))), + ("multiple_pastes", None), + ("backspace_after_pastes", None), + ]; + + for (name, input) in test_cases { + // Create a fresh composer for each test case + let mut composer = ChatComposer::new(true, sender.clone()); + + if let Some(text) = input { + composer.handle_paste(text); + } else if name == "multiple_pastes" { + // First large paste + composer.handle_paste("x".repeat(LARGE_PASTE_CHAR_THRESHOLD + 3)); + // Second large paste + composer.handle_paste("y".repeat(LARGE_PASTE_CHAR_THRESHOLD + 7)); + // Small paste + composer.handle_paste(" another short paste".to_string()); + } else if name == "backspace_after_pastes" { + // Three large pastes + composer.handle_paste("a".repeat(LARGE_PASTE_CHAR_THRESHOLD + 2)); + composer.handle_paste("b".repeat(LARGE_PASTE_CHAR_THRESHOLD + 4)); + composer.handle_paste("c".repeat(LARGE_PASTE_CHAR_THRESHOLD + 6)); + // Move cursor to end and press backspace + composer.textarea.move_cursor(tui_textarea::CursorMove::End); + composer.handle_key_event(KeyEvent::new(KeyCode::Backspace, KeyModifiers::NONE)); + } + + terminal + .draw(|f| f.render_widget_ref(&composer, f.area())) + .unwrap_or_else(|e| panic!("Failed to draw {name} composer: {e}")); + + assert_snapshot!(name, terminal.backend()); + } + } + + #[test] + fn test_multiple_pastes_submission() { + use crossterm::event::KeyCode; + use crossterm::event::KeyEvent; + use crossterm::event::KeyModifiers; + + let (tx, _rx) = std::sync::mpsc::channel(); + let sender = AppEventSender::new(tx); + let mut composer = ChatComposer::new(true, sender); + + // Define test cases: (paste content, is_large) + let test_cases = [ + ("x".repeat(LARGE_PASTE_CHAR_THRESHOLD + 3), true), + (" and ".to_string(), false), + ("y".repeat(LARGE_PASTE_CHAR_THRESHOLD + 7), true), + ]; + + // Expected states after each paste + let mut expected_text = String::new(); + let mut expected_pending_count = 0; + + // Apply all pastes and build expected state + let states: Vec<_> = test_cases + .iter() + .map(|(content, is_large)| { + composer.handle_paste(content.clone()); + if *is_large { + let placeholder = format!("[Pasted Content {} chars]", content.chars().count()); + expected_text.push_str(&placeholder); + expected_pending_count += 1; + } else { + expected_text.push_str(content); + } + (expected_text.clone(), expected_pending_count) + }) + .collect(); + + // Verify all intermediate states were correct + assert_eq!( + states, + vec![ + ( + format!("[Pasted Content {} chars]", test_cases[0].0.chars().count()), + 1 + ), + ( + format!( + "[Pasted Content {} chars] and ", + test_cases[0].0.chars().count() + ), + 1 + ), + ( + format!( + "[Pasted Content {} chars] and [Pasted Content {} chars]", + test_cases[0].0.chars().count(), + test_cases[2].0.chars().count() + ), + 2 + ), + ] + ); + + // Submit and verify final expansion + let (result, _) = + composer.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)); + if let InputResult::Submitted(text) = result { + assert_eq!(text, format!("{} and {}", test_cases[0].0, test_cases[2].0)); + } else { + panic!("expected Submitted"); + } + } + + #[test] + fn test_placeholder_deletion() { + use crossterm::event::KeyCode; + use crossterm::event::KeyEvent; + use crossterm::event::KeyModifiers; + + let (tx, _rx) = std::sync::mpsc::channel(); + let sender = AppEventSender::new(tx); + let mut composer = ChatComposer::new(true, sender); + + // Define test cases: (content, is_large) + let test_cases = [ + ("a".repeat(LARGE_PASTE_CHAR_THRESHOLD + 5), true), + (" and ".to_string(), false), + ("b".repeat(LARGE_PASTE_CHAR_THRESHOLD + 6), true), + ]; + + // Apply all pastes + let mut current_pos = 0; + let states: Vec<_> = test_cases + .iter() + .map(|(content, is_large)| { + composer.handle_paste(content.clone()); + if *is_large { + let placeholder = format!("[Pasted Content {} chars]", content.chars().count()); + current_pos += placeholder.len(); + } else { + current_pos += content.len(); + } + ( + composer.textarea.lines().join("\n"), + composer.pending_pastes.len(), + current_pos, + ) + }) + .collect(); + + // Delete placeholders one by one and collect states + let mut deletion_states = vec![]; + + // First deletion + composer + .textarea + .move_cursor(tui_textarea::CursorMove::Jump(0, states[0].2 as u16)); + composer.handle_key_event(KeyEvent::new(KeyCode::Backspace, KeyModifiers::NONE)); + deletion_states.push(( + composer.textarea.lines().join("\n"), + composer.pending_pastes.len(), + )); + + // Second deletion + composer + .textarea + .move_cursor(tui_textarea::CursorMove::Jump( + 0, + composer.textarea.lines().join("\n").len() as u16, + )); + composer.handle_key_event(KeyEvent::new(KeyCode::Backspace, KeyModifiers::NONE)); + deletion_states.push(( + composer.textarea.lines().join("\n"), + composer.pending_pastes.len(), + )); + + // Verify all states + assert_eq!( + deletion_states, + vec![ + (" and [Pasted Content 1006 chars]".to_string(), 1), + (" and ".to_string(), 0), + ] + ); + } + + #[test] + fn test_partial_placeholder_deletion() { + use crossterm::event::KeyCode; + use crossterm::event::KeyEvent; + use crossterm::event::KeyModifiers; + + let (tx, _rx) = std::sync::mpsc::channel(); + let sender = AppEventSender::new(tx); + let mut composer = ChatComposer::new(true, sender); + + // Define test cases: (cursor_position_from_end, expected_pending_count) + let test_cases = [ + 5, // Delete from middle - should clear tracking + 0, // Delete from end - should clear tracking + ]; + + let paste = "x".repeat(LARGE_PASTE_CHAR_THRESHOLD + 4); + let placeholder = format!("[Pasted Content {} chars]", paste.chars().count()); + + let states: Vec<_> = test_cases + .into_iter() + .map(|pos_from_end| { + composer.handle_paste(paste.clone()); + composer + .textarea + .move_cursor(tui_textarea::CursorMove::Jump( + 0, + (placeholder.len() - pos_from_end) as u16, + )); + composer.handle_key_event(KeyEvent::new(KeyCode::Backspace, KeyModifiers::NONE)); + let result = ( + composer.textarea.lines().join("\n").contains(&placeholder), + composer.pending_pastes.len(), + ); + composer.textarea.select_all(); + composer.textarea.cut(); + result + }) + .collect(); + + assert_eq!( + states, + vec![ + (false, 0), // After deleting from middle + (false, 0), // After deleting from end + ] + ); + } } diff --git a/codex-rs/tui/src/bottom_pane/mod.rs b/codex-rs/tui/src/bottom_pane/mod.rs index 96f5c70285..350492b3e9 100644 --- a/codex-rs/tui/src/bottom_pane/mod.rs +++ b/codex-rs/tui/src/bottom_pane/mod.rs @@ -82,6 +82,15 @@ impl BottomPane<'_> { } } + pub fn handle_paste(&mut self, pasted: String) { + if self.active_view.is_none() { + let needs_redraw = self.composer.handle_paste(pasted); + if needs_redraw { + self.request_redraw(); + } + } + } + /// Update the status indicator text (only when the `StatusIndicatorView` is /// active). pub(crate) fn update_status_text(&mut self, text: String) { diff --git a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__backspace_after_pastes.snap b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__backspace_after_pastes.snap new file mode 100644 index 0000000000..fa604c862b --- /dev/null +++ b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__backspace_after_pastes.snap @@ -0,0 +1,14 @@ +--- +source: tui/src/bottom_pane/chat_composer.rs +expression: terminal.backend() +--- +"╭──────────────────────────────────────────────────────────────────────────────────────────────────╮" +"│[Pasted Content 1002 chars][Pasted Content 1004 chars] │" +"│ │" +"│ │" +"│ │" +"│ │" +"│ │" +"│ │" +"│ │" +"╰───────────────────────────────────────────────Enter to send | Ctrl+D to quit | Ctrl+J for newline╯" diff --git a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__empty.snap b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__empty.snap new file mode 100644 index 0000000000..a89076d8aa --- /dev/null +++ b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__empty.snap @@ -0,0 +1,14 @@ +--- +source: tui/src/bottom_pane/chat_composer.rs +expression: terminal.backend() +--- +"╭──────────────────────────────────────────────────────────────────────────────────────────────────╮" +"│ send a message │" +"│ │" +"│ │" +"│ │" +"│ │" +"│ │" +"│ │" +"│ │" +"╰───────────────────────────────────────────────Enter to send | Ctrl+D to quit | Ctrl+J for newline╯" diff --git a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__large.snap b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__large.snap new file mode 100644 index 0000000000..39a62da400 --- /dev/null +++ b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__large.snap @@ -0,0 +1,14 @@ +--- +source: tui/src/bottom_pane/chat_composer.rs +expression: terminal.backend() +--- +"╭──────────────────────────────────────────────────────────────────────────────────────────────────╮" +"│[Pasted Content 1005 chars] │" +"│ │" +"│ │" +"│ │" +"│ │" +"│ │" +"│ │" +"│ │" +"╰───────────────────────────────────────────────Enter to send | Ctrl+D to quit | Ctrl+J for newline╯" diff --git a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__multiple_pastes.snap b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__multiple_pastes.snap new file mode 100644 index 0000000000..cd94095431 --- /dev/null +++ b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__multiple_pastes.snap @@ -0,0 +1,14 @@ +--- +source: tui/src/bottom_pane/chat_composer.rs +expression: terminal.backend() +--- +"╭──────────────────────────────────────────────────────────────────────────────────────────────────╮" +"│[Pasted Content 1003 chars][Pasted Content 1007 chars] another short paste │" +"│ │" +"│ │" +"│ │" +"│ │" +"│ │" +"│ │" +"│ │" +"╰───────────────────────────────────────────────Enter to send | Ctrl+D to quit | Ctrl+J for newline╯" diff --git a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__small.snap b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__small.snap new file mode 100644 index 0000000000..e6b55e36d8 --- /dev/null +++ b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__small.snap @@ -0,0 +1,14 @@ +--- +source: tui/src/bottom_pane/chat_composer.rs +expression: terminal.backend() +--- +"╭──────────────────────────────────────────────────────────────────────────────────────────────────╮" +"│short │" +"│ │" +"│ │" +"│ │" +"│ │" +"│ │" +"│ │" +"│ │" +"╰───────────────────────────────────────────────Enter to send | Ctrl+D to quit | Ctrl+J for newline╯" diff --git a/codex-rs/tui/src/chatwidget.rs b/codex-rs/tui/src/chatwidget.rs index 0b623132b5..865e339763 100644 --- a/codex-rs/tui/src/chatwidget.rs +++ b/codex-rs/tui/src/chatwidget.rs @@ -174,6 +174,12 @@ impl ChatWidget<'_> { } } + pub(crate) fn handle_paste(&mut self, text: String) { + if matches!(self.input_focus, InputFocus::BottomPane) { + self.bottom_pane.handle_paste(text); + } + } + fn submit_user_message(&mut self, user_message: UserMessage) { let UserMessage { text, image_paths } = user_message; let mut items: Vec = Vec::new(); From 94f5cad895df39b43edf565462c5b5d382ce441f Mon Sep 17 00:00:00 2001 From: Michael Bolin Date: Sat, 12 Jul 2025 16:22:02 -0700 Subject: [PATCH 2/7] fix: when invoking Codex via MCP, use the request id as the Submission id (#1554) Small quality-of-life improvement when using `codex mcp`. --- codex-rs/mcp-server/src/codex_tool_runner.rs | 21 +++++++++++++++----- 1 file changed, 16 insertions(+), 5 deletions(-) diff --git a/codex-rs/mcp-server/src/codex_tool_runner.rs b/codex-rs/mcp-server/src/codex_tool_runner.rs index 796a119e5c..7c3b02fe5e 100644 --- a/codex-rs/mcp-server/src/codex_tool_runner.rs +++ b/codex-rs/mcp-server/src/codex_tool_runner.rs @@ -9,6 +9,7 @@ use codex_core::protocol::Event; use codex_core::protocol::EventMsg; use codex_core::protocol::InputItem; use codex_core::protocol::Op; +use codex_core::protocol::Submission; use codex_core::protocol::TaskCompleteEvent; use mcp_types::CallToolResult; use mcp_types::CallToolResultContent; @@ -66,14 +67,24 @@ pub async fn run_codex_tool_session( .send(codex_event_to_notification(&first_event)) .await; - if let Err(e) = codex - .submit(Op::UserInput { + // Use the original MCP request ID as the `sub_id` for the Codex submission so that + // any events emitted for this tool-call can be correlated with the + // originating `tools/call` request. + let sub_id = match &id { + RequestId::String(s) => s.clone(), + RequestId::Integer(n) => n.to_string(), + }; + + let submission = Submission { + id: sub_id, + op: Op::UserInput { items: vec![InputItem::Text { text: initial_prompt.clone(), }], - }) - .await - { + }, + }; + + if let Err(e) = codex.submit_with_id(submission).await { tracing::error!("Failed to submit initial prompt: {e}"); } From c46bb67d77eb366596e2039b35ae29ce02ed14bf Mon Sep 17 00:00:00 2001 From: aibrahim-oai Date: Sat, 12 Jul 2025 16:53:55 -0700 Subject: [PATCH 3/7] Improve SSE tests (#1546) ## Summary - support fixture-based SSE data in tests - add helpers to load SSE JSON fixtures - add table-driven SSE unit tests - let integration tests use fixture loading - fix clippy errors from format! calls ## Testing - `cargo clippy --tests` - `cargo test --workspace --exclude codex-linux-sandbox` ------ https://chatgpt.com/codex/tasks/task_i_68717468c3e48321b51c9ecac6ba0f09 --- codex-rs/core/src/client.rs | 113 ++++++++++++++++++ .../tests/fixtures/completed_template.json | 16 +++ .../core/tests/fixtures/incomplete_sse.json | 3 + codex-rs/core/tests/previous_response_id.rs | 8 +- codex-rs/core/tests/stream_no_completed.rs | 10 +- codex-rs/core/tests/test_support.rs | 53 ++++++++ 6 files changed, 192 insertions(+), 11 deletions(-) create mode 100644 codex-rs/core/tests/fixtures/completed_template.json create mode 100644 codex-rs/core/tests/fixtures/incomplete_sse.json diff --git a/codex-rs/core/src/client.rs b/codex-rs/core/src/client.rs index bd2eeb9457..1b8e4c959d 100644 --- a/codex-rs/core/src/client.rs +++ b/codex-rs/core/src/client.rs @@ -391,3 +391,116 @@ async fn stream_from_fixture(path: impl AsRef) -> Result { tokio::spawn(process_sse(stream, tx_event)); Ok(ResponseStream { rx_event }) } + +#[cfg(test)] +mod tests { + #![allow(clippy::expect_used, clippy::unwrap_used)] + use super::*; + use serde_json::json; + + async fn run_sse(events: Vec) -> Vec { + let mut body = String::new(); + for e in events { + let kind = e + .get("type") + .and_then(|v| v.as_str()) + .expect("fixture event missing type"); + if e.as_object().map(|o| o.len() == 1).unwrap_or(false) { + body.push_str(&format!("event: {kind}\n\n")); + } else { + body.push_str(&format!("event: {kind}\ndata: {e}\n\n")); + } + } + let (tx, mut rx) = mpsc::channel::>(8); + let stream = ReaderStream::new(std::io::Cursor::new(body)).map_err(CodexErr::Io); + tokio::spawn(process_sse(stream, tx)); + let mut out = Vec::new(); + while let Some(ev) = rx.recv().await { + out.push(ev.expect("channel closed")); + } + out + } + + /// Verifies that the SSE adapter emits the expected [`ResponseEvent`] for + /// a variety of `type` values from the Responses API. The test is written + /// table-driven style to keep additions for new event kinds trivial. + /// + /// Each `Case` supplies an input event, a predicate that must match the + /// *first* `ResponseEvent` produced by the adapter, and the total number + /// of events expected after appending a synthetic `response.completed` + /// marker that terminates the stream. + #[tokio::test] + async fn table_driven_event_kinds() { + struct TestCase { + name: &'static str, + event: serde_json::Value, + expect_first: fn(&ResponseEvent) -> bool, + expected_len: usize, + } + + fn is_created(ev: &ResponseEvent) -> bool { + matches!(ev, ResponseEvent::Created) + } + + fn is_output(ev: &ResponseEvent) -> bool { + matches!(ev, ResponseEvent::OutputItemDone(_)) + } + + fn is_completed(ev: &ResponseEvent) -> bool { + matches!(ev, ResponseEvent::Completed { .. }) + } + + let completed = json!({ + "type": "response.completed", + "response": { + "id": "c", + "usage": { + "input_tokens": 0, + "input_tokens_details": null, + "output_tokens": 0, + "output_tokens_details": null, + "total_tokens": 0 + }, + "output": [] + } + }); + + let cases = vec![ + TestCase { + name: "created", + event: json!({"type": "response.created", "response": {}}), + expect_first: is_created, + expected_len: 2, + }, + TestCase { + name: "output_item.done", + event: json!({ + "type": "response.output_item.done", + "item": { + "type": "message", + "role": "assistant", + "content": [ + {"type": "output_text", "text": "hi"} + ] + } + }), + expect_first: is_output, + expected_len: 2, + }, + TestCase { + name: "unknown", + event: json!({"type": "response.new_tool_event"}), + expect_first: is_completed, + expected_len: 1, + }, + ]; + + for case in cases { + let mut evs = vec![case.event]; + evs.push(completed.clone()); + let out = run_sse(evs).await; + assert_eq!(out.len(), case.expected_len, "case {}", case.name); + assert!((case.expect_first)(&out[0]), "case {}", case.name); + } + } +} diff --git a/codex-rs/core/tests/fixtures/completed_template.json b/codex-rs/core/tests/fixtures/completed_template.json new file mode 100644 index 0000000000..1774dc5e84 --- /dev/null +++ b/codex-rs/core/tests/fixtures/completed_template.json @@ -0,0 +1,16 @@ +[ + { + "type": "response.completed", + "response": { + "id": "__ID__", + "usage": { + "input_tokens": 0, + "input_tokens_details": null, + "output_tokens": 0, + "output_tokens_details": null, + "total_tokens": 0 + }, + "output": [] + } + } +] diff --git a/codex-rs/core/tests/fixtures/incomplete_sse.json b/codex-rs/core/tests/fixtures/incomplete_sse.json new file mode 100644 index 0000000000..2876bbfd29 --- /dev/null +++ b/codex-rs/core/tests/fixtures/incomplete_sse.json @@ -0,0 +1,3 @@ +[ + {"type": "response.output_item.done"} +] diff --git a/codex-rs/core/tests/previous_response_id.rs b/codex-rs/core/tests/previous_response_id.rs index 10d6e8bf6a..e64271a0ff 100644 --- a/codex-rs/core/tests/previous_response_id.rs +++ b/codex-rs/core/tests/previous_response_id.rs @@ -11,6 +11,7 @@ mod test_support; use serde_json::Value; use tempfile::TempDir; use test_support::load_default_config_for_test; +use test_support::load_sse_fixture_with_id; use tokio::time::timeout; use wiremock::Match; use wiremock::Mock; @@ -42,12 +43,9 @@ impl Match for HasPrevId { } } -/// Build minimal SSE stream with completed marker. +/// Build minimal SSE stream with completed marker using the JSON fixture. fn sse_completed(id: &str) -> String { - format!( - "event: response.completed\n\ -data: {{\"type\":\"response.completed\",\"response\":{{\"id\":\"{id}\",\"output\":[]}}}}\n\n\n" - ) + load_sse_fixture_with_id("tests/fixtures/completed_template.json", id) } #[tokio::test(flavor = "multi_thread", worker_threads = 2)] diff --git a/codex-rs/core/tests/stream_no_completed.rs b/codex-rs/core/tests/stream_no_completed.rs index ece34ba299..da2736aa77 100644 --- a/codex-rs/core/tests/stream_no_completed.rs +++ b/codex-rs/core/tests/stream_no_completed.rs @@ -12,6 +12,8 @@ use codex_core::protocol::Op; mod test_support; use tempfile::TempDir; use test_support::load_default_config_for_test; +use test_support::load_sse_fixture; +use test_support::load_sse_fixture_with_id; use tokio::time::timeout; use wiremock::Mock; use wiremock::MockServer; @@ -22,15 +24,11 @@ use wiremock::matchers::method; use wiremock::matchers::path; fn sse_incomplete() -> String { - // Only a single line; missing the completed event. - "event: response.output_item.done\n\n".to_string() + load_sse_fixture("tests/fixtures/incomplete_sse.json") } fn sse_completed(id: &str) -> String { - format!( - "event: response.completed\n\ -data: {{\"type\":\"response.completed\",\"response\":{{\"id\":\"{id}\",\"output\":[]}}}}\n\n\n" - ) + load_sse_fixture_with_id("tests/fixtures/completed_template.json", id) } #[tokio::test(flavor = "multi_thread", worker_threads = 2)] diff --git a/codex-rs/core/tests/test_support.rs b/codex-rs/core/tests/test_support.rs index 532e3986d0..5dbe637101 100644 --- a/codex-rs/core/tests/test_support.rs +++ b/codex-rs/core/tests/test_support.rs @@ -21,3 +21,56 @@ pub fn load_default_config_for_test(codex_home: &TempDir) -> Config { ) .expect("defaults for test should always succeed") } + +/// Builds an SSE stream body from a JSON fixture. +/// +/// The fixture must contain an array of objects where each object represents a +/// single SSE event with at least a `type` field matching the `event:` value. +/// Additional fields become the JSON payload for the `data:` line. An object +/// with only a `type` field results in an event with no `data:` section. This +/// makes it trivial to extend the fixtures as OpenAI adds new event kinds or +/// fields. +pub fn load_sse_fixture(path: impl AsRef) -> String { + let events: Vec = + serde_json::from_reader(std::fs::File::open(path).expect("read fixture")) + .expect("parse JSON fixture"); + events + .into_iter() + .map(|e| { + let kind = e + .get("type") + .and_then(|v| v.as_str()) + .expect("fixture event missing type"); + if e.as_object().map(|o| o.len() == 1).unwrap_or(false) { + format!("event: {kind}\n\n") + } else { + format!("event: {kind}\ndata: {e}\n\n") + } + }) + .collect() +} + +/// Same as [`load_sse_fixture`], but replaces the placeholder `__ID__` in the +/// fixture template with the supplied identifier before parsing. This lets a +/// single JSON template be reused by multiple tests that each need a unique +/// `response_id`. +pub fn load_sse_fixture_with_id(path: impl AsRef, id: &str) -> String { + let raw = std::fs::read_to_string(path).expect("read fixture template"); + let replaced = raw.replace("__ID__", id); + let events: Vec = + serde_json::from_str(&replaced).expect("parse JSON fixture"); + events + .into_iter() + .map(|e| { + let kind = e + .get("type") + .and_then(|v| v.as_str()) + .expect("fixture event missing type"); + if e.as_object().map(|o| o.len() == 1).unwrap_or(false) { + format!("event: {kind}\n\n") + } else { + format!("event: {kind}\ndata: {e}\n\n") + } + }) + .collect() +} From 0f8ac923904716e77f73b8e8f34b6891e4a88287 Mon Sep 17 00:00:00 2001 From: aibrahim-oai Date: Sat, 12 Jul 2025 17:20:35 -0700 Subject: [PATCH 4/7] Allow deadcode in test_support (#1555) #1546 Was pushed while not passing the clippy integration tests. This is fixing it. --- codex-rs/core/tests/test_support.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/codex-rs/core/tests/test_support.rs b/codex-rs/core/tests/test_support.rs index 5dbe637101..7d1e3a7fef 100644 --- a/codex-rs/core/tests/test_support.rs +++ b/codex-rs/core/tests/test_support.rs @@ -30,6 +30,7 @@ pub fn load_default_config_for_test(codex_home: &TempDir) -> Config { /// with only a `type` field results in an event with no `data:` section. This /// makes it trivial to extend the fixtures as OpenAI adds new event kinds or /// fields. +#[allow(dead_code)] pub fn load_sse_fixture(path: impl AsRef) -> String { let events: Vec = serde_json::from_reader(std::fs::File::open(path).expect("read fixture")) @@ -54,6 +55,7 @@ pub fn load_sse_fixture(path: impl AsRef) -> String { /// fixture template with the supplied identifier before parsing. This lets a /// single JSON template be reused by multiple tests that each need a unique /// `response_id`. +#[allow(dead_code)] pub fn load_sse_fixture_with_id(path: impl AsRef, id: &str) -> String { let raw = std::fs::read_to_string(path).expect("read fixture template"); let replaced = raw.replace("__ID__", id); From 3777e18243e51ea53f55a1a43cd658a141e7a272 Mon Sep 17 00:00:00 2001 From: aibrahim-oai Date: Sat, 12 Jul 2025 18:05:58 -0700 Subject: [PATCH 5/7] Add CLI streaming integration tests (#1542) ## Summary - add integration test for chat mode streaming via CLI using wiremock - add integration test for Responses API streaming via fixture - call `cargo run` to invoke the CLI during tests ## Testing - `cargo test -p codex-core --test cli_stream -- --nocapture` - `cargo clippy --all-targets --all-features -- -D warnings` ------ https://chatgpt.com/codex/tasks/task_i_68715980bbec8321999534fdd6a013c1 --- codex-rs/core/tests/cli_responses_fixture.sse | 8 ++ codex-rs/core/tests/cli_stream.rs | 119 ++++++++++++++++++ 2 files changed, 127 insertions(+) create mode 100644 codex-rs/core/tests/cli_responses_fixture.sse create mode 100644 codex-rs/core/tests/cli_stream.rs diff --git a/codex-rs/core/tests/cli_responses_fixture.sse b/codex-rs/core/tests/cli_responses_fixture.sse new file mode 100644 index 0000000000..d297ebafb2 --- /dev/null +++ b/codex-rs/core/tests/cli_responses_fixture.sse @@ -0,0 +1,8 @@ +event: response.created +data: {"type":"response.created","response":{"id":"resp1"}} + +event: response.output_item.done +data: {"type":"response.output_item.done","item":{"type":"message","role":"assistant","content":[{"type":"output_text","text":"fixture hello"}]}} + +event: response.completed +data: {"type":"response.completed","response":{"id":"resp1","output":[]}} diff --git a/codex-rs/core/tests/cli_stream.rs b/codex-rs/core/tests/cli_stream.rs new file mode 100644 index 0000000000..df3fedfd48 --- /dev/null +++ b/codex-rs/core/tests/cli_stream.rs @@ -0,0 +1,119 @@ +#![expect(clippy::unwrap_used)] + +use assert_cmd::Command as AssertCommand; +use codex_core::exec::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR; +use tempfile::TempDir; +use wiremock::Mock; +use wiremock::MockServer; +use wiremock::ResponseTemplate; +use wiremock::matchers::method; +use wiremock::matchers::path; + +/// Tests streaming chat completions through the CLI using a mock server. +/// This test: +/// 1. Sets up a mock server that simulates OpenAI's chat completions API +/// 2. Configures codex to use this mock server via a custom provider +/// 3. Sends a simple "hello?" prompt and verifies the streamed response +/// 4. Ensures the response is received exactly once and contains "hi" +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn chat_mode_stream_cli() { + if std::env::var(CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR).is_ok() { + println!( + "Skipping test because it cannot execute when network is disabled in a Codex sandbox." + ); + return; + } + + let server = MockServer::start().await; + let sse = concat!( + "data: {\"choices\":[{\"delta\":{\"content\":\"hi\"}}]}\n\n", + "data: {\"choices\":[{\"delta\":{}}]}\n\n", + "data: [DONE]\n\n" + ); + Mock::given(method("POST")) + .and(path("/v1/chat/completions")) + .respond_with( + ResponseTemplate::new(200) + .insert_header("content-type", "text/event-stream") + .set_body_raw(sse, "text/event-stream"), + ) + .expect(1) + .mount(&server) + .await; + + let home = TempDir::new().unwrap(); + let provider_override = format!( + "model_providers.mock={{ name = \"mock\", base_url = \"{}/v1\", env_key = \"PATH\", wire_api = \"chat\" }}", + server.uri() + ); + let mut cmd = AssertCommand::new("cargo"); + cmd.arg("run") + .arg("-p") + .arg("codex-cli") + .arg("--quiet") + .arg("--") + .arg("exec") + .arg("--skip-git-repo-check") + .arg("-c") + .arg(&provider_override) + .arg("-c") + .arg("model_provider=\"mock\"") + .arg("-C") + .arg(env!("CARGO_MANIFEST_DIR")) + .arg("hello?"); + cmd.env("CODEX_HOME", home.path()) + .env("OPENAI_API_KEY", "dummy") + .env("OPENAI_BASE_URL", format!("{}/v1", server.uri())); + + let output = cmd.output().unwrap(); + println!("Status: {}", output.status); + println!("Stdout:\n{}", String::from_utf8_lossy(&output.stdout)); + println!("Stderr:\n{}", String::from_utf8_lossy(&output.stderr)); + assert!(output.status.success()); + let stdout = String::from_utf8_lossy(&output.stdout); + assert!(stdout.contains("hi")); + assert_eq!(stdout.matches("hi").count(), 1); + + server.verify().await; +} + +/// Tests streaming responses through the CLI using a local SSE fixture file. +/// This test: +/// 1. Uses a pre-recorded SSE response fixture instead of a live server +/// 2. Configures codex to read from this fixture via CODEX_RS_SSE_FIXTURE env var +/// 3. Sends a "hello?" prompt and verifies the response +/// 4. Ensures the fixture content is correctly streamed through the CLI +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn responses_api_stream_cli() { + if std::env::var(CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR).is_ok() { + println!( + "Skipping test because it cannot execute when network is disabled in a Codex sandbox." + ); + return; + } + + let fixture = + std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/cli_responses_fixture.sse"); + + let home = TempDir::new().unwrap(); + let mut cmd = AssertCommand::new("cargo"); + cmd.arg("run") + .arg("-p") + .arg("codex-cli") + .arg("--quiet") + .arg("--") + .arg("exec") + .arg("--skip-git-repo-check") + .arg("-C") + .arg(env!("CARGO_MANIFEST_DIR")) + .arg("hello?"); + cmd.env("CODEX_HOME", home.path()) + .env("OPENAI_API_KEY", "dummy") + .env("CODEX_RS_SSE_FIXTURE", fixture) + .env("OPENAI_BASE_URL", "http://unused.local"); + + let output = cmd.output().unwrap(); + assert!(output.status.success()); + let stdout = String::from_utf8_lossy(&output.stdout); + assert!(stdout.contains("fixture hello")); +} From 9c0b413fd1fd6f99ed1d9b3be349e62f826abf7f Mon Sep 17 00:00:00 2001 From: Michael Bolin Date: Mon, 14 Jul 2025 09:41:11 -0700 Subject: [PATCH 6/7] docs: clarify the build process for the npm release (#1568) It appears that `0.5.0` was built with `stage_release.sh` instead of `stage_rust_release.py`, so add docs to clarify this and recommend running `--version` on the release candidate to verify the right thing was built. --- codex-cli/scripts/README.md | 9 +++++++++ codex-cli/scripts/stage_release.sh | 8 +++----- 2 files changed, 12 insertions(+), 5 deletions(-) create mode 100644 codex-cli/scripts/README.md diff --git a/codex-cli/scripts/README.md b/codex-cli/scripts/README.md new file mode 100644 index 0000000000..21e4f3e883 --- /dev/null +++ b/codex-cli/scripts/README.md @@ -0,0 +1,9 @@ +# npm releases + +Run the following: + +To build the 0.2.x or later version of the npm module, which runs the Rust version of the CLI, build it as follows: + +```bash +./codex-cli/scripts/stage_rust_release.py --release-version 0.6.0 +``` diff --git a/codex-cli/scripts/stage_release.sh b/codex-cli/scripts/stage_release.sh index 29b9f76783..cd32ade6f9 100755 --- a/codex-cli/scripts/stage_release.sh +++ b/codex-cli/scripts/stage_release.sh @@ -4,10 +4,7 @@ # ----------------------------------------------------------------------------- # Stages an npm release for @openai/codex. # -# The script used to accept a single optional positional argument that indicated -# the temporary directory in which to stage the package. We now support a -# flag-based interface so that we can extend the command with further options -# without breaking the call-site contract. +# Usage: # # --tmp : Use instead of a freshly created temp directory. # --native : Bundle the pre-built Rust CLI binaries for Linux alongside @@ -141,7 +138,8 @@ popd >/dev/null echo "Staged version $VERSION for release in $TMPDIR" if [[ "$INCLUDE_NATIVE" -eq 1 ]]; then - echo "Test Rust:" + echo "Verify the CLI:" + echo " node ${TMPDIR}/bin/codex.js --version" echo " node ${TMPDIR}/bin/codex.js --help" else echo "Test Node:" From f14b5adabf5db34864c44c1ffc6c566b018fe0cc Mon Sep 17 00:00:00 2001 From: aibrahim-oai Date: Mon, 14 Jul 2025 14:51:32 -0700 Subject: [PATCH 7/7] Add SSE Response parser tests (#1541) ## Summary - add `tokio-test` dev dependency - implement response stream parsing unit tests ## Testing - `cargo clippy -p codex-core --tests -- -D warnings` - `cargo test -p codex-core -- --nocapture` ------ https://chatgpt.com/codex/tasks/task_i_687163f3b2208321a6ce2adbef3fbc06 --- codex-rs/Cargo.lock | 47 ++++++++++++ codex-rs/core/Cargo.toml | 1 + codex-rs/core/src/client.rs | 147 +++++++++++++++++++++++++++++++++--- 3 files changed, 184 insertions(+), 11 deletions(-) diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lock index 3de3e78198..e59dbfa255 100644 --- a/codex-rs/Cargo.lock +++ b/codex-rs/Cargo.lock @@ -250,6 +250,28 @@ dependencies = [ "pin-project-lite", ] +[[package]] +name = "async-stream" +version = "0.3.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b5a71a6f37880a80d1d7f19efd781e4b5de42c88f0722cc13bcb6cc2cfe8476" +dependencies = [ + "async-stream-impl", + "futures-core", + "pin-project-lite", +] + +[[package]] +name = "async-stream-impl" +version = "0.3.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c7c24de15d275a1ecfd47a380fb4d5ec9bfe0933f309ed5e705b775596a3574d" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.104", +] + [[package]] name = "async-trait" version = "0.1.88" @@ -654,6 +676,7 @@ dependencies = [ "thiserror 2.0.12", "time", "tokio", + "tokio-test", "tokio-util", "toml 0.9.1", "tracing", @@ -4516,6 +4539,30 @@ dependencies = [ "tokio", ] +[[package]] +name = "tokio-stream" +version = "0.1.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eca58d7bba4a75707817a2c44174253f9236b2d5fbd055602e9d5c07c139a047" +dependencies = [ + "futures-core", + "pin-project-lite", + "tokio", +] + +[[package]] +name = "tokio-test" +version = "0.4.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2468baabc3311435b55dd935f702f42cd1b8abb7e754fb7dfb16bd36aa88f9f7" +dependencies = [ + "async-stream", + "bytes", + "futures-core", + "tokio", + "tokio-stream", +] + [[package]] name = "tokio-util" version = "0.7.15" diff --git a/codex-rs/core/Cargo.toml b/codex-rs/core/Cargo.toml index 22636102c9..c55d7d395d 100644 --- a/codex-rs/core/Cargo.toml +++ b/codex-rs/core/Cargo.toml @@ -64,4 +64,5 @@ maplit = "1.0.2" predicates = "3" pretty_assertions = "1.4.1" tempfile = "3" +tokio-test = "0.4" wiremock = "0.6" diff --git a/codex-rs/core/src/client.rs b/codex-rs/core/src/client.rs index 1b8e4c959d..2fa182cf7f 100644 --- a/codex-rs/core/src/client.rs +++ b/codex-rs/core/src/client.rs @@ -395,9 +395,39 @@ async fn stream_from_fixture(path: impl AsRef) -> Result { #[cfg(test)] mod tests { #![allow(clippy::expect_used, clippy::unwrap_used)] + use super::*; use serde_json::json; + use tokio::sync::mpsc; + use tokio_test::io::Builder as IoBuilder; + use tokio_util::io::ReaderStream; + // ──────────────────────────── + // Helpers + // ──────────────────────────── + + /// Runs the SSE parser on pre-chunked byte slices and returns every event + /// (including any final `Err` from a stream-closure check). + async fn collect_events(chunks: &[&[u8]]) -> Vec> { + let mut builder = IoBuilder::new(); + for chunk in chunks { + builder.read(chunk); + } + + let reader = builder.build(); + let stream = ReaderStream::new(reader).map_err(CodexErr::Io); + let (tx, mut rx) = mpsc::channel::>(16); + tokio::spawn(process_sse(stream, tx)); + + let mut events = Vec::new(); + while let Some(ev) = rx.recv().await { + events.push(ev); + } + events + } + + /// Builds an in-memory SSE stream from JSON fixtures and returns only the + /// successfully parsed events (panics on internal channel errors). async fn run_sse(events: Vec) -> Vec { let mut body = String::new(); for e in events { @@ -411,9 +441,11 @@ mod tests { body.push_str(&format!("event: {kind}\ndata: {e}\n\n")); } } + let (tx, mut rx) = mpsc::channel::>(8); let stream = ReaderStream::new(std::io::Cursor::new(body)).map_err(CodexErr::Io); tokio::spawn(process_sse(stream, tx)); + let mut out = Vec::new(); while let Some(ev) = rx.recv().await { out.push(ev.expect("channel closed")); @@ -421,14 +453,104 @@ mod tests { out } - /// Verifies that the SSE adapter emits the expected [`ResponseEvent`] for - /// a variety of `type` values from the Responses API. The test is written - /// table-driven style to keep additions for new event kinds trivial. - /// - /// Each `Case` supplies an input event, a predicate that must match the - /// *first* `ResponseEvent` produced by the adapter, and the total number - /// of events expected after appending a synthetic `response.completed` - /// marker that terminates the stream. + // ──────────────────────────── + // Tests from `implement-test-for-responses-api-sse-parser` + // ──────────────────────────── + + #[tokio::test] + async fn parses_items_and_completed() { + let item1 = json!({ + "type": "response.output_item.done", + "item": { + "type": "message", + "role": "assistant", + "content": [{"type": "output_text", "text": "Hello"}] + } + }) + .to_string(); + + let item2 = json!({ + "type": "response.output_item.done", + "item": { + "type": "message", + "role": "assistant", + "content": [{"type": "output_text", "text": "World"}] + } + }) + .to_string(); + + let completed = json!({ + "type": "response.completed", + "response": { "id": "resp1" } + }) + .to_string(); + + let sse1 = format!("event: response.output_item.done\ndata: {item1}\n\n"); + let sse2 = format!("event: response.output_item.done\ndata: {item2}\n\n"); + let sse3 = format!("event: response.completed\ndata: {completed}\n\n"); + + let events = collect_events(&[sse1.as_bytes(), sse2.as_bytes(), sse3.as_bytes()]).await; + + assert_eq!(events.len(), 3); + + matches!( + &events[0], + Ok(ResponseEvent::OutputItemDone(ResponseItem::Message { role, .. })) + if role == "assistant" + ); + + matches!( + &events[1], + Ok(ResponseEvent::OutputItemDone(ResponseItem::Message { role, .. })) + if role == "assistant" + ); + + match &events[2] { + Ok(ResponseEvent::Completed { + response_id, + token_usage, + }) => { + assert_eq!(response_id, "resp1"); + assert!(token_usage.is_none()); + } + other => panic!("unexpected third event: {other:?}"), + } + } + + #[tokio::test] + async fn error_when_missing_completed() { + let item1 = json!({ + "type": "response.output_item.done", + "item": { + "type": "message", + "role": "assistant", + "content": [{"type": "output_text", "text": "Hello"}] + } + }) + .to_string(); + + let sse1 = format!("event: response.output_item.done\ndata: {item1}\n\n"); + + let events = collect_events(&[sse1.as_bytes()]).await; + + assert_eq!(events.len(), 2); + + matches!(events[0], Ok(ResponseEvent::OutputItemDone(_))); + + match &events[1] { + Err(CodexErr::Stream(msg)) => { + assert_eq!(msg, "stream closed before response.completed") + } + other => panic!("unexpected second event: {other:?}"), + } + } + + // ──────────────────────────── + // Table-driven test from `main` + // ──────────────────────────── + + /// Verifies that the adapter produces the right `ResponseEvent` for a + /// variety of incoming `type` values. #[tokio::test] async fn table_driven_event_kinds() { struct TestCase { @@ -441,11 +563,9 @@ mod tests { fn is_created(ev: &ResponseEvent) -> bool { matches!(ev, ResponseEvent::Created) } - fn is_output(ev: &ResponseEvent) -> bool { matches!(ev, ResponseEvent::OutputItemDone(_)) } - fn is_completed(ev: &ResponseEvent) -> bool { matches!(ev, ResponseEvent::Completed { .. }) } @@ -498,9 +618,14 @@ mod tests { for case in cases { let mut evs = vec![case.event]; evs.push(completed.clone()); + let out = run_sse(evs).await; assert_eq!(out.len(), case.expected_len, "case {}", case.name); - assert!((case.expect_first)(&out[0]), "case {}", case.name); + assert!( + (case.expect_first)(&out[0]), + "first event mismatch in case {}", + case.name + ); } } }