From 50c227a6e24eef3e1cd21321348be812b6d2d87c Mon Sep 17 00:00:00 2001 From: Charlie Marsh Date: Tue, 17 Nov 2026 02:52:25 +0000 Subject: [PATCH] Bound item loading for paginated `read_thread` calls (#61955) ## Why `read_thread` returns at most 20 items per turn, but requesting full turns loads every item in paginated history before trimming the result. ## What changed For paginated threads, request turn metadata without items, then fetch the newest 20 items per turn concurrently through `thread/items/list`. Restore chronological item order before building the response and share the item limit with the summary code. ## Testing Add a regression test that verifies the newest 20 items are returned in order with `includeOutputs` both enabled and disabled. GitOrigin-RevId: ba73a322cac7ee5262135a271f3574dc22d9d78c --- codex-rs/tui/src/dynamic_tools.rs | 41 +++++++++++++- codex-rs/tui/src/dynamic_tools_tests.rs | 71 +++++++++++++++++++++---- 2 files changed, 100 insertions(+), 12 deletions(-) diff --git a/codex-rs/tui/src/dynamic_tools.rs b/codex-rs/tui/src/dynamic_tools.rs index 7245c6a339..c170df1e11 100644 --- a/codex-rs/tui/src/dynamic_tools.rs +++ b/codex-rs/tui/src/dynamic_tools.rs @@ -81,6 +81,7 @@ const DEFAULT_LIST_LIMIT: u32 = 10; const MAX_LIST_LIMIT: u32 = 50; const DEFAULT_READ_TURN_LIMIT: u32 = 1; const MAX_READ_TURN_LIMIT: u32 = 10; +const READ_ITEMS_PER_TURN: u32 = 20; const DEFAULT_OUTPUT_CHARS: usize = 2_000; const MAX_OUTPUT_CHARS: usize = 20_000; const MAX_ERROR_CHARS: usize = 248; @@ -404,6 +405,7 @@ async fn execute_inner( )); } let thread = read_thread(&handle, &arguments.thread_id).await?; + let paginated = thread.history_mode == ThreadHistoryMode::Paginated; let page: Result = handle .request_typed(ClientRequest::ThreadTurnsList { request_id: RequestId::String(format!("tui-dynamic-{}", Uuid::new_v4())), @@ -412,11 +414,46 @@ async fn execute_inner( cursor: arguments.cursor.clone(), limit: Some(turn_limit), sort_direction: Some(SortDirection::Desc), - items_view: Some(TurnItemsView::Full), + items_view: Some(if paginated { + TurnItemsView::NotLoaded + } else { + TurnItemsView::Full + }), }, }) .await; let (turns, next_cursor) = match page { + Ok(page) if paginated => { + let turns = + futures::future::try_join_all(page.data.into_iter().map(|mut turn| { + let handle = &handle; + let thread_id = &arguments.thread_id; + async move { + let items: ThreadItemsListResponse = + request(handle, |request_id| ClientRequest::ThreadItemsList { + request_id, + params: ThreadItemsListParams { + thread_id: thread_id.clone(), + turn_id: Some(turn.id.clone()), + cursor: None, + limit: Some(READ_ITEMS_PER_TURN), + sort_direction: Some(SortDirection::Desc), + defer_output: None, + }, + }) + .await?; + turn.items = items + .data + .into_iter() + .rev() + .map(|entry| entry.item) + .collect(); + Ok::<_, String>(turn) + } + })) + .await?; + (turns, page.next_cursor) + } Ok(page) => (page.data, page.next_cursor), Err(TypedRequestError::Server { source, .. }) if crate::app_server_session::is_history_pagination_unsupported(&source) => @@ -1599,7 +1636,7 @@ fn turn_summary(turn: &Turn, include_outputs: bool, output_chars: usize) -> Valu "type": "contextCompaction", "id": id }), }) - .take(20) + .take(READ_ITEMS_PER_TURN as usize) .collect(); items.reverse(); json!({ diff --git a/codex-rs/tui/src/dynamic_tools_tests.rs b/codex-rs/tui/src/dynamic_tools_tests.rs index b0ddd27e49..f11fbdd0c1 100644 --- a/codex-rs/tui/src/dynamic_tools_tests.rs +++ b/codex-rs/tui/src/dynamic_tools_tests.rs @@ -14,6 +14,7 @@ use tempfile::TempDir; async fn test_server( tool_arguments: Value, + older_messages: usize, ) -> color_eyre::Result<(TempDir, AppServerSession, String, String)> { let codex_home = tempfile::tempdir()?; let config = ConfigBuilder::default() @@ -34,12 +35,26 @@ async fn test_server( .lines() .map(serde_json::from_str::) .collect::, _>>()?; - for payload in [ + let start = json!({ + "type": "task_started", + "turn_id": "persisted-turn", + "model_context_window": null + }); + let messages = (0..older_messages).map(|i| { json!({ - "type": "task_started", + "type": "item_completed", + "thread_id": target, "turn_id": "persisted-turn", - "model_context_window": null - }), + "item": { + "type": "AgentMessage", + "id": format!("older-{i}"), + "phase": "commentary", + "content": [{"type":"Text","text":"Working"}] + }, + "completed_at_ms": 0 + }) + }); + for payload in std::iter::once(start).chain(messages).chain([ json!({ "type": "item_completed", "thread_id": target, @@ -72,7 +87,7 @@ async fn test_server( "turn_id": "persisted-turn", "last_agent_message": "Persisted assistant output" }), - ] { + ]) { serde_json::from_value::(payload.clone())?; records.push(json!({ "timestamp": "2026-01-02T00:00:00Z", @@ -143,10 +158,44 @@ fn response_json(response: DynamicToolCallResponse) -> Value { serde_json::from_str(text).expect("dynamic tool response should contain JSON") } +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn read_thread_returns_the_newest_twenty_items_in_order() -> color_eyre::Result<()> { + let (_home, server, source, target) = test_server(json!({}), /*older_messages*/ 25).await?; + let mut expected = (7..25).map(|i| format!("older-{i}")).collect::>(); + expected.extend([ + "persisted-message".to_string(), + "persisted-tool".to_string(), + ]); + for include_outputs in [false, true] { + let read = response_json( + call_tool( + &server, + &source, + "read_thread", + json!({ + "threadId": target, "includeOutputs": include_outputs + }), + ) + .await, + ); + let ids = read["turns"][0]["items"] + .as_array() + .unwrap() + .iter() + .map(|item| item["id"].as_str().unwrap()) + .collect::>(); + assert_eq!(ids, expected); + } + Ok(()) +} + #[tokio::test(flavor = "multi_thread", worker_threads = 2)] async fn oversized_read_preserves_answer_in_next_model_request() -> color_eyre::Result<()> { - let (_home, app_server, source, target) = - test_server(json!({"padding": "supporting tool arguments".repeat(4_000)})).await?; + let (_home, app_server, source, target) = test_server( + json!({"padding": "supporting tool arguments".repeat(4_000)}), + /*older_messages*/ 0, + ) + .await?; let mock_server = responses::start_mock_server().await; let call_id = "read-task"; let mock = responses::mount_sse_sequence( @@ -445,7 +494,7 @@ fn file_backed_image_generation_is_retained_as_a_reference() -> color_eyre::Resu #[tokio::test] async fn task_management_tools_use_existing_app_server_operations() -> color_eyre::Result<()> { - let (codex_home, server, source, target) = test_server(json!({})).await?; + let (codex_home, server, source, target) = test_server(json!({}), /*older_messages*/ 0).await?; let listed = response_json(call_tool(&server, &source, "list_threads", json!({})).await); assert!( @@ -618,7 +667,8 @@ async fn task_management_tools_use_existing_app_server_operations() -> color_eyr #[tokio::test] async fn wait_threads_preserves_snapshots_and_rejects_self_wait() -> color_eyre::Result<()> { - let (_codex_home, server, source, target) = test_server(json!({})).await?; + let (_codex_home, server, source, target) = + test_server(json!({}), /*older_messages*/ 0).await?; let snapshot = response_json( call_tool( @@ -710,7 +760,8 @@ async fn wait_threads_preserves_snapshots_and_rejects_self_wait() -> color_eyre: #[tokio::test] async fn task_creation_and_followup_start_background_turns() -> color_eyre::Result<()> { - let (codex_home, mut server, source, target) = test_server(json!({})).await?; + let (codex_home, mut server, source, target) = + test_server(json!({}), /*older_messages*/ 0).await?; for (tool, arguments) in [ (