mirror of
https://github.com/openai/codex.git
synced 2026-11-15 21:50:46 +00:00
Paginate TUI transcript history (#36950)
## What changed - Load older transcript items in bounded pages as users scroll upward, and let `Home` continue fetching until the start of the thread. - Show loading, partial-history, retry, and complete states in the transcript overlay while preserving the visible scroll position as pages are prepended. - Use paginated history for resume, fork, retry, and prompt-edit flows, while falling back to legacy history requests when the app server does not support pagination. ## Testing - Cover multi-page transcript loading, page-boundary prompt reconciliation, legacy-server fallback, bounded retry history, and transcript history-state rendering. GitOrigin-RevId: cc6b764bc4185d079b2f68bedf235c1d08278dfb
This commit is contained in:
@@ -9,6 +9,7 @@ use super::*;
|
||||
use crate::app_server_session::ForkGoalContinuation;
|
||||
use crate::config_update::format_config_error;
|
||||
use crate::external_agent_config_migration::flow::ExternalAgentConfigMigrationFlowOutcome;
|
||||
use crate::pager_overlay::TranscriptHistoryState;
|
||||
#[cfg(target_os = "windows")]
|
||||
use codex_config::types::WindowsSandboxModeToml;
|
||||
|
||||
@@ -43,6 +44,12 @@ impl App {
|
||||
.await
|
||||
{
|
||||
app_server.cancel_older_history_page(thread_id);
|
||||
if self.chat_widget.thread_id() == Some(thread_id)
|
||||
&& let Some(Overlay::Transcript(overlay)) = self.overlay.as_mut()
|
||||
{
|
||||
overlay.set_history_state(TranscriptHistoryState::Failed);
|
||||
tui.frame_requester().schedule_frame();
|
||||
}
|
||||
tracing::warn!(%thread_id, error = %err, "failed to load older transcript history");
|
||||
}
|
||||
}
|
||||
@@ -282,12 +289,13 @@ impl App {
|
||||
self.refresh_in_memory_config_from_disk_best_effort("forking the thread")
|
||||
.await;
|
||||
let config = self.fresh_session_config();
|
||||
let started = match app_server
|
||||
.thread_read(thread_id, /*include_turns*/ true)
|
||||
.await
|
||||
{
|
||||
Ok(thread) => match crate::app_backtrack::backtrack_fork_before_turn_id(
|
||||
&thread.turns,
|
||||
let turns = match self.thread_event_channels.get(&thread_id) {
|
||||
Some(channel) => Some(channel.store.lock().await.turns.clone()),
|
||||
None => None,
|
||||
};
|
||||
let started = match turns {
|
||||
Some(turns) => match crate::app_backtrack::backtrack_fork_before_turn_id(
|
||||
&turns,
|
||||
nth_user_message,
|
||||
&mut prompt,
|
||||
) {
|
||||
@@ -296,7 +304,7 @@ impl App {
|
||||
|| app_server.has_older_history(thread_id) =>
|
||||
{
|
||||
let before_turn_id = before_turn_id
|
||||
.or_else(|| thread.turns.first().map(|turn| turn.id.clone()));
|
||||
.or_else(|| turns.first().map(|turn| turn.id.clone()));
|
||||
app_server
|
||||
.fork_thread_at(
|
||||
config.clone(),
|
||||
@@ -316,7 +324,9 @@ impl App {
|
||||
}
|
||||
Err(err) => Err(err),
|
||||
},
|
||||
Err(err) => Err(err),
|
||||
None => Err(color_eyre::eyre::eyre!(
|
||||
"the selected thread is no longer available for prompt editing"
|
||||
)),
|
||||
};
|
||||
match started {
|
||||
Ok(forked) => {
|
||||
@@ -352,6 +362,10 @@ impl App {
|
||||
self.insert_history_cell(tui, cell);
|
||||
}
|
||||
AppEvent::EndInitialHistoryReplayBuffer => {
|
||||
self.scrollback_has_older_history = self
|
||||
.chat_widget
|
||||
.thread_id()
|
||||
.is_some_and(|thread_id| app_server.has_older_history(thread_id));
|
||||
self.finish_initial_history_replay_buffer(tui);
|
||||
}
|
||||
AppEvent::ConsolidateAgentMessage {
|
||||
|
||||
@@ -3,12 +3,56 @@
|
||||
use std::collections::HashSet;
|
||||
|
||||
use super::*;
|
||||
use crate::app_server_session::HISTORY_ITEM_PAGE_LIMIT;
|
||||
use crate::app_server_session::thread_items_page_params;
|
||||
use crate::history_cell::UserHistoryCell;
|
||||
use crate::pager_overlay::TranscriptHistoryState;
|
||||
use crate::thread_transcript::RawReasoningVisibility;
|
||||
use crate::thread_transcript::thread_items_to_transcript_cells;
|
||||
use codex_app_server_protocol::ClientRequest;
|
||||
use codex_app_server_protocol::ThreadItemsListResponse;
|
||||
|
||||
impl App {
|
||||
/// Start one bounded page request shared by transcript-history navigation.
|
||||
pub(crate) fn request_older_history_page(
|
||||
&self,
|
||||
app_server: &mut AppServerSession,
|
||||
thread_id: ThreadId,
|
||||
) -> bool {
|
||||
let Some(cursor) = app_server.begin_older_history_page(thread_id) else {
|
||||
return false;
|
||||
};
|
||||
tracing::debug!(
|
||||
%thread_id,
|
||||
%cursor,
|
||||
overlay = self.overlay.is_some(),
|
||||
"loading older transcript history page"
|
||||
);
|
||||
let request_id = app_server.next_request_id();
|
||||
let request_handle = app_server.request_handle();
|
||||
let app_event_tx = self.app_event_tx.clone();
|
||||
tokio::spawn(async move {
|
||||
let result = request_handle
|
||||
.request_typed::<ThreadItemsListResponse>(ClientRequest::ThreadItemsList {
|
||||
request_id,
|
||||
params: thread_items_page_params(
|
||||
thread_id,
|
||||
/*turn_id*/ None,
|
||||
Some(cursor.clone()),
|
||||
HISTORY_ITEM_PAGE_LIMIT,
|
||||
),
|
||||
})
|
||||
.await
|
||||
.map_err(|err| err.to_string());
|
||||
app_event_tx.send(AppEvent::OlderThreadHistoryLoaded {
|
||||
thread_id,
|
||||
cursor,
|
||||
result,
|
||||
});
|
||||
});
|
||||
true
|
||||
}
|
||||
|
||||
pub(super) async fn handle_older_history_page(
|
||||
&mut self,
|
||||
tui: &mut tui::Tui,
|
||||
@@ -173,9 +217,24 @@ impl App {
|
||||
.count(),
|
||||
);
|
||||
}
|
||||
self.scrollback_has_older_history = app_server.has_older_history(thread_id);
|
||||
let mut continue_to_start = false;
|
||||
if let Some(Overlay::Transcript(overlay)) = self.overlay.as_mut() {
|
||||
let index = overlay.prepend(cells.clone(), width);
|
||||
self.transcript_cells.splice(index..index, cells);
|
||||
let previous_state = overlay.set_history_state(if self.scrollback_has_older_history {
|
||||
TranscriptHistoryState::Partial
|
||||
} else {
|
||||
TranscriptHistoryState::Complete
|
||||
});
|
||||
continue_to_start = previous_state == TranscriptHistoryState::LoadingBeginning
|
||||
&& self.scrollback_has_older_history;
|
||||
}
|
||||
if continue_to_start
|
||||
&& self.request_older_history_page(app_server, thread_id)
|
||||
&& let Some(Overlay::Transcript(overlay)) = self.overlay.as_mut()
|
||||
{
|
||||
overlay.set_history_state(TranscriptHistoryState::LoadingBeginning);
|
||||
}
|
||||
if self.backtrack.overlay_preview_active {
|
||||
self.apply_backtrack_selection_internal(self.backtrack.nth_user_message);
|
||||
|
||||
@@ -171,6 +171,7 @@ impl App {
|
||||
self.chat_widget.clear_pending_token_activity_refreshes();
|
||||
self.chat_widget.clear_pending_rate_limit_reset_hint();
|
||||
self.initial_history_replay_buffer = None;
|
||||
self.scrollback_has_older_history = false;
|
||||
self.backtrack = BacktrackState::default();
|
||||
self.backtrack_render_pending = false;
|
||||
self.skill_load_warnings.clear();
|
||||
|
||||
@@ -254,13 +254,11 @@ impl App {
|
||||
}
|
||||
|
||||
if app_keymap_shortcuts_available && self.keymap.app.open_transcript.is_pressed(key_event) {
|
||||
// Enter alternate screen and set viewport to full size.
|
||||
let _ = tui.enter_alt_screen();
|
||||
self.overlay = Some(Overlay::new_transcript(
|
||||
self.transcript_cells.clone(),
|
||||
self.keymap.pager.clone(),
|
||||
));
|
||||
tui.frame_requester().schedule_frame();
|
||||
self.scrollback_has_older_history = self
|
||||
.chat_widget
|
||||
.thread_id()
|
||||
.is_some_and(|thread_id| app_server.has_older_history(thread_id));
|
||||
self.open_transcript_overlay(tui);
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
@@ -3,9 +3,12 @@
|
||||
use super::session_lifecycle::ThreadAttachPresentation;
|
||||
use super::*;
|
||||
use crate::app_server_session::ForkGoalContinuation;
|
||||
use crate::app_server_session::HISTORY_ITEM_PAGE_LIMIT;
|
||||
use crate::chatwidget::ThreadInputState;
|
||||
use crate::chatwidget::ThreadInputStateRestoreMode;
|
||||
use crate::chatwidget::UserMessage;
|
||||
use codex_app_server_protocol::ThreadHistoryMode;
|
||||
use codex_app_server_protocol::TurnItemsView;
|
||||
use codex_app_server_protocol::UserInput;
|
||||
|
||||
pub(super) struct SafetyBufferedRetry {
|
||||
@@ -76,9 +79,52 @@ impl App {
|
||||
return;
|
||||
}
|
||||
|
||||
let thread = match app_server
|
||||
.thread_read(thread_id, /*include_turns*/ true)
|
||||
.await
|
||||
let thread = match async {
|
||||
let mut thread = app_server
|
||||
.thread_read(thread_id, /*include_turns*/ false)
|
||||
.await?;
|
||||
if thread.history_mode == ThreadHistoryMode::Legacy {
|
||||
app_server
|
||||
.hydrate_initial_thread_history(
|
||||
&mut thread,
|
||||
/*turn_cursor*/ None,
|
||||
/*item_cursor*/ None,
|
||||
/*config*/ None,
|
||||
crate::app_server_session::HistoryHydrationScope::Initial,
|
||||
)
|
||||
.await?;
|
||||
} else {
|
||||
let page = app_server
|
||||
.thread_turns_page(thread_id, /*cursor*/ None)
|
||||
.await?;
|
||||
thread.turns = page.data.into_iter().rev().collect();
|
||||
if let Some(turn_index) = thread.turns.iter().position(|turn| turn.id == turn_id) {
|
||||
let page = app_server
|
||||
.thread_items_page(
|
||||
thread_id,
|
||||
Some(&turn_id),
|
||||
/*cursor*/ None,
|
||||
HISTORY_ITEM_PAGE_LIMIT,
|
||||
)
|
||||
.await?;
|
||||
if page.next_cursor.is_some() {
|
||||
color_eyre::eyre::bail!(
|
||||
"Cannot safely retry a turn whose input exceeds the bounded history page."
|
||||
);
|
||||
}
|
||||
let turn = &mut thread.turns[turn_index];
|
||||
turn.items = page
|
||||
.data
|
||||
.into_iter()
|
||||
.rev()
|
||||
.map(|entry| entry.item)
|
||||
.collect();
|
||||
turn.items_view = TurnItemsView::Full;
|
||||
}
|
||||
}
|
||||
Ok::<_, color_eyre::Report>(thread)
|
||||
}
|
||||
.await
|
||||
{
|
||||
Ok(thread) => thread,
|
||||
Err(err) => {
|
||||
|
||||
@@ -31,3 +31,14 @@ fn retry_rejects_a_stale_or_in_progress_turn() {
|
||||
assert!(safety_retry_fork_point(&in_progress, "missing").is_err());
|
||||
assert!(safety_retry_fork_point(&previous_in_progress, "turn-2").is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn retry_accepts_a_targeted_latest_turn_and_its_completed_predecessor() {
|
||||
let turns = vec![
|
||||
turn("turn-1", TurnStatus::Completed),
|
||||
turn("turn-2", TurnStatus::Interrupted),
|
||||
];
|
||||
|
||||
assert!(safety_retry_fork_point(&turns, "turn-2").is_ok());
|
||||
assert!(safety_retry_fork_point(&turns[1..], "turn-2").is_ok());
|
||||
}
|
||||
|
||||
@@ -384,22 +384,24 @@ impl App {
|
||||
error = %resume_err,
|
||||
"failed to resume live thread for selection; falling back to thread/read"
|
||||
);
|
||||
let (thread, turns) = match app_server
|
||||
.thread_read(thread_id, /*include_turns*/ true)
|
||||
let mut thread = app_server
|
||||
.thread_read(thread_id, /*include_turns*/ false)
|
||||
.await?;
|
||||
match app_server
|
||||
.hydrate_initial_thread_history(
|
||||
&mut thread,
|
||||
/*turn_cursor*/ None,
|
||||
/*item_cursor*/ None,
|
||||
Some(&self.config),
|
||||
crate::app_server_session::HistoryHydrationScope::Initial,
|
||||
)
|
||||
.await
|
||||
{
|
||||
Ok(thread) => {
|
||||
let turns = thread.turns.clone();
|
||||
(thread, turns)
|
||||
}
|
||||
Err(err) if Self::can_fallback_from_include_turns_error(&err) => {
|
||||
let thread = app_server
|
||||
.thread_read(thread_id, /*include_turns*/ false)
|
||||
.await?;
|
||||
(thread, Vec::new())
|
||||
}
|
||||
Ok(()) => {}
|
||||
Err(err) if Self::can_fallback_from_include_turns_error(&err) => {}
|
||||
Err(err) => return Err(err),
|
||||
};
|
||||
}
|
||||
let turns = thread.turns.clone();
|
||||
if turns.is_empty() {
|
||||
// A `thread/read` fallback without turns would create a blank local replay
|
||||
// channel with no live listener attached, which blocks later real re-attach.
|
||||
|
||||
@@ -38,6 +38,7 @@ pub(super) async fn make_test_app() -> App {
|
||||
has_emitted_history_lines: false,
|
||||
transcript_reflow: TranscriptReflowState::default(),
|
||||
initial_history_replay_buffer: None,
|
||||
scrollback_has_older_history: false,
|
||||
enhanced_keys_supported: false,
|
||||
keymap: crate::keymap::RuntimeKeymap::defaults(),
|
||||
key_chord_matcher: crate::keymap::KeyChordMatcher::default(),
|
||||
|
||||
@@ -4740,6 +4740,7 @@ async fn make_test_app() -> App {
|
||||
has_emitted_history_lines: false,
|
||||
transcript_reflow: TranscriptReflowState::default(),
|
||||
initial_history_replay_buffer: None,
|
||||
scrollback_has_older_history: false,
|
||||
enhanced_keys_supported: false,
|
||||
keymap: crate::keymap::RuntimeKeymap::defaults(),
|
||||
key_chord_matcher: crate::keymap::KeyChordMatcher::default(),
|
||||
@@ -4809,6 +4810,7 @@ async fn make_test_app_with_channels() -> (
|
||||
has_emitted_history_lines: false,
|
||||
transcript_reflow: TranscriptReflowState::default(),
|
||||
initial_history_replay_buffer: None,
|
||||
scrollback_has_older_history: false,
|
||||
enhanced_keys_supported: false,
|
||||
keymap: crate::keymap::RuntimeKeymap::defaults(),
|
||||
key_chord_matcher: crate::keymap::KeyChordMatcher::default(),
|
||||
|
||||
@@ -8,6 +8,7 @@ use codex_app_server_protocol::ClientRequest;
|
||||
use codex_app_server_protocol::JSONRPCError;
|
||||
use codex_app_server_protocol::JSONRPCErrorError;
|
||||
use codex_app_server_protocol::JSONRPCMessage;
|
||||
use codex_app_server_protocol::JSONRPCRequest;
|
||||
use codex_app_server_protocol::JSONRPCResponse;
|
||||
use codex_app_server_protocol::SortDirection;
|
||||
use codex_app_server_protocol::ThreadItemsListParams;
|
||||
@@ -34,17 +35,27 @@ use tokio::task::JoinHandle;
|
||||
use tokio_tungstenite::accept_async;
|
||||
use tokio_tungstenite::tungstenite::Message;
|
||||
|
||||
type RecordedRequests = Arc<Mutex<Vec<JSONRPCRequest>>>;
|
||||
type RecordingAppServer = (AppServerSession, RecordedRequests, JoinHandle<Result<()>>);
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
enum HistoryCapabilities {
|
||||
Current,
|
||||
LegacyOnly,
|
||||
LegacyOnlyUnsupportedVariant,
|
||||
}
|
||||
|
||||
/// Returns and resets `(thread/loaded/list, thread/read)` request counts.
|
||||
fn take_backfill_counts(requests: &Arc<Mutex<Vec<String>>>) -> (usize, usize) {
|
||||
fn take_backfill_counts(requests: &RecordedRequests) -> (usize, usize) {
|
||||
let requests = std::mem::take(&mut *requests.lock().expect("request recorder lock"));
|
||||
(
|
||||
requests
|
||||
.iter()
|
||||
.filter(|method| *method == "thread/loaded/list")
|
||||
.filter(|request| request.method == "thread/loaded/list")
|
||||
.count(),
|
||||
requests
|
||||
.iter()
|
||||
.filter(|method| *method == "thread/read")
|
||||
.filter(|request| request.method == "thread/read")
|
||||
.count(),
|
||||
)
|
||||
}
|
||||
@@ -52,13 +63,25 @@ fn take_backfill_counts(requests: &Arc<Mutex<Vec<String>>>) -> (usize, usize) {
|
||||
/// Starts an embedded app server behind a loopback WebSocket proxy that records JSON-RPC methods.
|
||||
async fn start_recording_app_server(
|
||||
config: &Config,
|
||||
blocked_thread_list: Option<(ThreadId, oneshot::Sender<()>, oneshot::Receiver<()>)>,
|
||||
failed_thread_name: Option<&'static str>,
|
||||
) -> Result<RecordingAppServer> {
|
||||
start_recording_app_server_with_history(
|
||||
config,
|
||||
HistoryCapabilities::Current,
|
||||
blocked_thread_list,
|
||||
failed_thread_name,
|
||||
)
|
||||
.await
|
||||
}
|
||||
|
||||
/// Proxies a real app server while optionally rejecting modern pagination like an older server.
|
||||
async fn start_recording_app_server_with_history(
|
||||
config: &Config,
|
||||
history_capabilities: HistoryCapabilities,
|
||||
mut blocked_thread_list: Option<(ThreadId, oneshot::Sender<()>, oneshot::Receiver<()>)>,
|
||||
failed_thread_name: Option<&'static str>,
|
||||
) -> Result<(
|
||||
AppServerSession,
|
||||
Arc<Mutex<Vec<String>>>,
|
||||
JoinHandle<Result<()>>,
|
||||
)> {
|
||||
) -> Result<RecordingAppServer> {
|
||||
let state_db =
|
||||
crate::init_state_db_for_app_server_target(config, &crate::AppServerTarget::Embedded)
|
||||
.await?;
|
||||
@@ -107,42 +130,79 @@ async fn start_recording_app_server(
|
||||
request_sink
|
||||
.lock()
|
||||
.expect("request recorder lock")
|
||||
.push(request.method.clone());
|
||||
.push(request.clone());
|
||||
let request_id = request.id.clone();
|
||||
let request =
|
||||
serde_json::from_value::<ClientRequest>(serde_json::to_value(request)?)?;
|
||||
if let ClientRequest::ThreadList { params, .. } = &request
|
||||
&& let Some((root, started, release)) = blocked_thread_list.take()
|
||||
let params = request.params.as_ref();
|
||||
let requires_pagination = match request.method.as_str() {
|
||||
"thread/start" => params
|
||||
.and_then(|params| params.get("historyMode"))
|
||||
.is_some_and(|mode| !mode.is_null()),
|
||||
"thread/resume" | "thread/fork" => params
|
||||
.and_then(|params| params.get("excludeTurns"))
|
||||
.and_then(serde_json::Value::as_bool)
|
||||
.unwrap_or(false),
|
||||
"thread/turns/list" | "thread/items/list" => true,
|
||||
_ => false,
|
||||
};
|
||||
let response = if matches!(
|
||||
history_capabilities,
|
||||
HistoryCapabilities::LegacyOnly
|
||||
| HistoryCapabilities::LegacyOnlyUnsupportedVariant
|
||||
) && requires_pagination
|
||||
{
|
||||
assert_eq!(params.ancestor_thread_id, Some(root.to_string()));
|
||||
assert_eq!(params.sort_direction, Some(SortDirection::Desc));
|
||||
let _ = started.send(());
|
||||
let _ = release.await;
|
||||
}
|
||||
let force_failure = matches!(
|
||||
&request,
|
||||
ClientRequest::ThreadSetName { params, .. }
|
||||
if failed_thread_name == Some(params.name.as_str())
|
||||
);
|
||||
let response = if force_failure {
|
||||
let (code, message) = if history_capabilities
|
||||
== HistoryCapabilities::LegacyOnlyUnsupportedVariant
|
||||
&& request.method == "thread/start"
|
||||
{
|
||||
(-32602, "unknown variant \"paginated\", expected \"legacy\"")
|
||||
} else {
|
||||
(-32601, "method not found")
|
||||
};
|
||||
JSONRPCMessage::Error(JSONRPCError {
|
||||
id: request_id,
|
||||
error: JSONRPCErrorError {
|
||||
code: -32603,
|
||||
message: "forced thread/name/set failure".to_string(),
|
||||
code,
|
||||
data: None,
|
||||
message: message.to_string(),
|
||||
},
|
||||
})
|
||||
} else {
|
||||
match embedded.request(request).await? {
|
||||
Ok(result) => JSONRPCMessage::Response(JSONRPCResponse {
|
||||
let request = serde_json::from_value::<ClientRequest>(
|
||||
serde_json::to_value(request)?,
|
||||
)?;
|
||||
if let ClientRequest::ThreadList { params, .. } = &request
|
||||
&& let Some((root, started, release)) = blocked_thread_list.take()
|
||||
{
|
||||
assert_eq!(params.ancestor_thread_id, Some(root.to_string()));
|
||||
assert_eq!(params.sort_direction, Some(SortDirection::Desc));
|
||||
let _ = started.send(());
|
||||
let _ = release.await;
|
||||
}
|
||||
let force_failure = matches!(
|
||||
&request,
|
||||
ClientRequest::ThreadSetName { params, .. }
|
||||
if failed_thread_name == Some(params.name.as_str())
|
||||
);
|
||||
if force_failure {
|
||||
JSONRPCMessage::Error(JSONRPCError {
|
||||
id: request_id,
|
||||
result,
|
||||
}),
|
||||
Err(error) => JSONRPCMessage::Error(JSONRPCError {
|
||||
id: request_id,
|
||||
error,
|
||||
}),
|
||||
error: JSONRPCErrorError {
|
||||
code: -32603,
|
||||
message: "forced thread/name/set failure".to_string(),
|
||||
data: None,
|
||||
},
|
||||
})
|
||||
} else {
|
||||
match embedded.request(request).await? {
|
||||
Ok(result) => JSONRPCMessage::Response(JSONRPCResponse {
|
||||
id: request_id,
|
||||
result,
|
||||
}),
|
||||
Err(error) => JSONRPCMessage::Error(JSONRPCError {
|
||||
id: request_id,
|
||||
error,
|
||||
}),
|
||||
}
|
||||
}
|
||||
};
|
||||
websocket
|
||||
@@ -180,12 +240,40 @@ async fn start_recording_app_server(
|
||||
))
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn older_pagination_reconciles_review_prompts_across_page_boundaries() -> Result<()> {
|
||||
fn create_legacy_history_rollout(config: &Config) -> Result<ThreadId> {
|
||||
let thread_id = create_fake_rollout(
|
||||
config.codex_home.as_path(),
|
||||
"2026-01-02T00-00-00",
|
||||
"2026-01-02T00:00:00Z",
|
||||
"legacy history",
|
||||
Some(config.model_provider_id.as_str()),
|
||||
/*git_info*/ None,
|
||||
)
|
||||
.map_err(|err| color_eyre::eyre::eyre!("failed to create history rollout: {err}"))?;
|
||||
Ok(ThreadId::from_string(&thread_id)?)
|
||||
}
|
||||
|
||||
fn recorded_params(requests: &RecordedRequests, method: &str) -> Vec<serde_json::Value> {
|
||||
requests
|
||||
.lock()
|
||||
.expect("request recorder lock")
|
||||
.iter()
|
||||
.filter(|request| request.method == method)
|
||||
.map(|request| request.params.clone().unwrap_or(serde_json::Value::Null))
|
||||
.collect()
|
||||
}
|
||||
|
||||
async fn make_history_test_app() -> Result<(App, tempfile::TempDir)> {
|
||||
let mut app = make_test_app().await;
|
||||
let codex_home = tempdir()?;
|
||||
app.config.codex_home = codex_home.path().to_path_buf().abs();
|
||||
app.config.sqlite = SqliteConfig::new_for_testing(codex_home.path().abs());
|
||||
Ok((app, codex_home))
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn older_pagination_reconciles_review_prompts_across_page_boundaries() -> Result<()> {
|
||||
let (mut app, codex_home) = make_history_test_app().await?;
|
||||
app.config.terminal_resize_reflow.max_rows = TerminalResizeReflowMaxRows::Limit(100);
|
||||
let thread_id = create_fake_paginated_rollout(
|
||||
codex_home.path(),
|
||||
@@ -377,6 +465,277 @@ async fn older_pagination_reconciles_review_prompts_across_page_boundaries() ->
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn transcript_home_loads_every_older_history_page() -> Result<()> {
|
||||
let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await;
|
||||
let codex_home = tempdir()?;
|
||||
app.config.codex_home = codex_home.path().to_path_buf().abs();
|
||||
app.config.sqlite = SqliteConfig::new_for_testing(codex_home.path().abs());
|
||||
app.config.terminal_resize_reflow.max_rows = TerminalResizeReflowMaxRows::Limit(2);
|
||||
let thread_id = create_fake_paginated_rollout(
|
||||
codex_home.path(),
|
||||
"2026-01-02T00-00-00",
|
||||
"2026-01-02T00:00:00Z",
|
||||
"multi-page transcript",
|
||||
Some(app.config.model_provider_id.as_str()),
|
||||
/*git_info*/ None,
|
||||
)
|
||||
.map_err(|error| color_eyre::eyre::eyre!("failed to create paginated rollout: {error}"))?;
|
||||
let thread_id = ThreadId::from_string(&thread_id)?;
|
||||
let path = rollout_path(
|
||||
codex_home.path(),
|
||||
"2026-01-02T00-00-00",
|
||||
&thread_id.to_string(),
|
||||
);
|
||||
let mut records = std::fs::read_to_string(&path)?
|
||||
.lines()
|
||||
.map(serde_json::from_str::<serde_json::Value>)
|
||||
.collect::<Result<Vec<_>, _>>()?;
|
||||
let events = std::iter::once(EventMsg::TurnStarted(TurnStartedEvent {
|
||||
turn_id: "multi-page-turn".to_string(),
|
||||
trace_id: None,
|
||||
started_at: None,
|
||||
model_context_window: None,
|
||||
collaboration_mode_kind: Default::default(),
|
||||
}))
|
||||
.chain((0..305).map(|index| {
|
||||
EventMsg::ItemCompleted(ItemCompletedEvent {
|
||||
thread_id,
|
||||
turn_id: "multi-page-turn".to_string(),
|
||||
item: TurnItem::AgentMessage(AgentMessageItem {
|
||||
id: format!("history-item-{index}"),
|
||||
content: vec![AgentMessageContent::Text {
|
||||
text: format!("history output {index}"),
|
||||
}],
|
||||
phase: None,
|
||||
memory_citation: None,
|
||||
}),
|
||||
started_at_ms: None,
|
||||
completed_at_ms: 0,
|
||||
})
|
||||
}));
|
||||
for event in events {
|
||||
records.push(serde_json::json!({
|
||||
"timestamp": "2026-01-02T00:00:00Z",
|
||||
"ordinal": records.len(),
|
||||
"type": "event_msg",
|
||||
"payload": serde_json::to_value(event)?,
|
||||
}));
|
||||
}
|
||||
let records = records
|
||||
.into_iter()
|
||||
.map(|record| record.to_string())
|
||||
.collect::<Vec<_>>()
|
||||
.join("\n");
|
||||
std::fs::write(path, format!("{records}\n"))?;
|
||||
|
||||
let (mut app_server, requests, proxy) = start_recording_app_server(
|
||||
&app.config,
|
||||
/*blocked_thread_list*/ None,
|
||||
/*failed_thread_name*/ None,
|
||||
)
|
||||
.await?;
|
||||
let started = app_server
|
||||
.resume_thread(
|
||||
app.config.clone(),
|
||||
thread_id,
|
||||
crate::app_server_session::ResumeModelSettings::RestoreFromThread,
|
||||
)
|
||||
.await?;
|
||||
let initial_cells = crate::thread_transcript::thread_items_to_transcript_cells(
|
||||
Some(thread_id),
|
||||
&app.config.cwd,
|
||||
started.turns.iter().flat_map(|turn| turn.items.clone()),
|
||||
crate::thread_transcript::RawReasoningVisibility::Hidden,
|
||||
Some(app.config.codex_home.as_path()),
|
||||
);
|
||||
app.enqueue_primary_thread_session(started.session, started.turns)
|
||||
.await?;
|
||||
app.transcript_cells = initial_cells;
|
||||
app.scrollback_has_older_history = app_server.has_older_history(thread_id);
|
||||
assert!(app.scrollback_has_older_history);
|
||||
while app_event_rx.try_recv().is_ok() {}
|
||||
let initial_page_requests = recorded_params(&requests, "thread/items/list").len();
|
||||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||||
app.open_transcript_overlay(&mut tui);
|
||||
|
||||
app.handle_backtrack_overlay_event(
|
||||
&mut tui,
|
||||
&mut app_server,
|
||||
TuiEvent::Key(KeyEvent::new(KeyCode::Home, KeyModifiers::NONE)),
|
||||
)
|
||||
.await?;
|
||||
while app_server.has_older_history(thread_id) {
|
||||
let event = tokio::time::timeout(Duration::from_secs(5), app_event_rx.recv())
|
||||
.await?
|
||||
.ok_or_else(|| color_eyre::eyre::eyre!("history event channel closed"))?;
|
||||
if matches!(event, AppEvent::OlderThreadHistoryLoaded { .. }) {
|
||||
app.handle_event(&mut tui, &mut app_server, event).await?;
|
||||
}
|
||||
}
|
||||
|
||||
assert!(recorded_params(&requests, "thread/items/list").len() >= initial_page_requests + 3);
|
||||
assert!(app.transcript_cells.iter().any(|cell| {
|
||||
cell.display_lines(/*width*/ 80)
|
||||
.iter()
|
||||
.any(|line| line.to_string().contains("history output 0"))
|
||||
}));
|
||||
let Some(Overlay::Transcript(overlay)) = app.overlay.as_mut() else {
|
||||
panic!("expected transcript overlay after Home navigation");
|
||||
};
|
||||
let area = Rect::new(
|
||||
/*x*/ 0, /*y*/ 0, /*width*/ 80, /*height*/ 12,
|
||||
);
|
||||
let mut buffer = Buffer::empty(area);
|
||||
overlay.render(area, &mut buffer);
|
||||
let visible = (area.y..area.bottom())
|
||||
.map(|y| {
|
||||
(area.x..area.right())
|
||||
.map(|x| buffer[(x, y)].symbol())
|
||||
.collect::<String>()
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
.join("\n");
|
||||
assert!(visible.contains("history output 0"), "{visible}");
|
||||
assert!(!visible.contains("history output 304"), "{visible}");
|
||||
app_server.shutdown().await?;
|
||||
proxy.await??;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn remote_legacy_history_start_negotiates_once_for_resume_and_fork() -> Result<()> {
|
||||
let (app, _codex_home) = make_history_test_app().await?;
|
||||
let legacy_thread_id = create_legacy_history_rollout(&app.config)?;
|
||||
let (mut app_server, requests, proxy) = start_recording_app_server_with_history(
|
||||
&app.config,
|
||||
HistoryCapabilities::LegacyOnly,
|
||||
/*blocked_thread_list*/ None,
|
||||
/*failed_thread_name*/ None,
|
||||
)
|
||||
.await?;
|
||||
|
||||
let started = app_server.start_thread(&app.config).await?;
|
||||
let resumed = app_server
|
||||
.resume_thread(
|
||||
app.config.clone(),
|
||||
legacy_thread_id,
|
||||
crate::app_server_session::ResumeModelSettings::RestoreFromThread,
|
||||
)
|
||||
.await?;
|
||||
let forked = app_server
|
||||
.fork_thread(app.config.clone(), legacy_thread_id)
|
||||
.await?;
|
||||
|
||||
assert_ne!(started.session.thread_id, legacy_thread_id);
|
||||
assert_eq!(resumed.session.thread_id, legacy_thread_id);
|
||||
assert_ne!(forked.session.thread_id, legacy_thread_id);
|
||||
let starts = recorded_params(&requests, "thread/start");
|
||||
assert_eq!(starts.len(), 2);
|
||||
assert_eq!(starts[0]["historyMode"], "paginated");
|
||||
assert_eq!(starts[1]["historyMode"], serde_json::Value::Null);
|
||||
|
||||
for method in ["thread/resume", "thread/fork"] {
|
||||
let params = recorded_params(&requests, method);
|
||||
assert_eq!(params.len(), 1, "legacy {method} must not be reprobed");
|
||||
assert_ne!(params[0]["excludeTurns"], true);
|
||||
}
|
||||
assert!(recorded_params(&requests, "thread/turns/list").is_empty());
|
||||
assert!(recorded_params(&requests, "thread/items/list").is_empty());
|
||||
|
||||
app_server.shutdown().await?;
|
||||
proxy.await??;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn remote_legacy_history_start_retries_unsupported_paginated_variant() -> Result<()> {
|
||||
let (app, _codex_home) = make_history_test_app().await?;
|
||||
let (mut app_server, requests, proxy) = start_recording_app_server_with_history(
|
||||
&app.config,
|
||||
HistoryCapabilities::LegacyOnlyUnsupportedVariant,
|
||||
/*blocked_thread_list*/ None,
|
||||
/*failed_thread_name*/ None,
|
||||
)
|
||||
.await?;
|
||||
|
||||
app_server.start_thread(&app.config).await?;
|
||||
|
||||
let starts = recorded_params(&requests, "thread/start");
|
||||
assert_eq!(starts.len(), 2);
|
||||
assert_eq!(starts[0]["historyMode"], "paginated");
|
||||
assert_eq!(starts[1]["historyMode"], serde_json::Value::Null);
|
||||
|
||||
app_server.shutdown().await?;
|
||||
proxy.await??;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
enum LegacyHistoryRequest {
|
||||
Resume,
|
||||
Fork,
|
||||
}
|
||||
|
||||
async fn assert_remote_legacy_history_retry(request: LegacyHistoryRequest) -> Result<()> {
|
||||
let (app, _codex_home) = make_history_test_app().await?;
|
||||
let legacy_thread_id = create_legacy_history_rollout(&app.config)?;
|
||||
let (mut app_server, requests, proxy) = start_recording_app_server_with_history(
|
||||
&app.config,
|
||||
HistoryCapabilities::LegacyOnly,
|
||||
/*blocked_thread_list*/ None,
|
||||
/*failed_thread_name*/ None,
|
||||
)
|
||||
.await?;
|
||||
|
||||
let method = match request {
|
||||
LegacyHistoryRequest::Resume => {
|
||||
let resumed = app_server
|
||||
.resume_thread(
|
||||
app.config.clone(),
|
||||
legacy_thread_id,
|
||||
crate::app_server_session::ResumeModelSettings::RestoreFromThread,
|
||||
)
|
||||
.await?;
|
||||
assert_eq!(resumed.session.thread_id, legacy_thread_id);
|
||||
"thread/resume"
|
||||
}
|
||||
LegacyHistoryRequest::Fork => {
|
||||
let forked = app_server
|
||||
.fork_thread(app.config.clone(), legacy_thread_id)
|
||||
.await?;
|
||||
assert_ne!(forked.session.thread_id, legacy_thread_id);
|
||||
"thread/fork"
|
||||
}
|
||||
};
|
||||
let attempts = recorded_params(&requests, method);
|
||||
if request == LegacyHistoryRequest::Resume {
|
||||
assert_eq!(attempts.len(), 2);
|
||||
assert_eq!(attempts[0]["excludeTurns"], true);
|
||||
} else {
|
||||
assert_eq!(attempts.len(), 1);
|
||||
}
|
||||
assert_ne!(
|
||||
attempts.last().expect("history request")["excludeTurns"],
|
||||
true
|
||||
);
|
||||
assert!(recorded_params(&requests, "thread/turns/list").is_empty());
|
||||
assert!(recorded_params(&requests, "thread/items/list").is_empty());
|
||||
|
||||
app_server.shutdown().await?;
|
||||
proxy.await??;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn remote_legacy_history_resume_retries_generic_method_not_found() -> Result<()> {
|
||||
assert_remote_legacy_history_retry(LegacyHistoryRequest::Resume).await
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn remote_legacy_history_fork_avoids_unsupported_fields() -> Result<()> {
|
||||
assert_remote_legacy_history_retry(LegacyHistoryRequest::Fork).await
|
||||
}
|
||||
#[test]
|
||||
fn fresh_session_applies_requested_name() -> Result<()> {
|
||||
const TEST_STACK_SIZE_BYTES: usize = 8 * 1024 * 1024;
|
||||
@@ -420,7 +779,7 @@ fn fresh_session_applies_requested_name() -> Result<()> {
|
||||
.lock()
|
||||
.expect("request recorder lock")
|
||||
.iter()
|
||||
.any(|method| method == "thread/name/set"),
|
||||
.any(|request| request.method == "thread/name/set"),
|
||||
"fresh session should be named through the app server"
|
||||
);
|
||||
let thread = app_server
|
||||
@@ -664,7 +1023,7 @@ fn session_lifecycle_avoids_redundant_subagent_metadata_reads() -> Result<()> {
|
||||
.lock()
|
||||
.expect("request recorder lock")
|
||||
.iter()
|
||||
.filter(|method| *method == "thread/list")
|
||||
.filter(|request| request.method == "thread/list")
|
||||
.count(),
|
||||
1
|
||||
);
|
||||
|
||||
Reference in New Issue
Block a user