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
This commit is contained in:
Charlie Marsh
2026-11-17 03:16:31 +00:00
committed by copyberry
parent 1443c64c62
commit 50c227a6e2
2 changed files with 100 additions and 12 deletions
+39 -2
View File
@@ -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<ThreadTurnsListResponse, TypedRequestError> = 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!({
+61 -10
View File
@@ -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::<Value>)
.collect::<Result<Vec<_>, _>>()?;
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::<codex_protocol::protocol::EventMsg>(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::<Vec<_>>();
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::<Vec<_>>();
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 [
(