Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Avoid cloning excluded turn items during thread resume (#46511)

Charlie Marsh05a93a8a1d73
diff --git a/codex-rs/app-server-protocol/src/protocol/mod.rs b/codex-rs/app-server-protocol/src/protocol/mod.rs
index 3a90aa7045..4becfaa126 100644
--- a/codex-rs/app-server-protocol/src/protocol/mod.rs
+++ b/codex-rs/app-server-protocol/src/protocol/mod.rs
@@ -8,5 +8,6 @@ mod mappers;
mod serde_helpers;
pub mod thread_history;
pub mod thread_history_projection;
+mod turn_items_view;
pub mod v1;
pub mod v2;
diff --git a/codex-rs/app-server-protocol/src/protocol/thread_history.rs b/codex-rs/app-server-protocol/src/protocol/thread_history.rs
index 4cc2d56532..6a2ad271f0 100644
--- a/codex-rs/app-server-protocol/src/protocol/thread_history.rs
+++ b/codex-rs/app-server-protocol/src/protocol/thread_history.rs
@@ -280,10 +280,15 @@ impl ThreadHistoryBuilder {
}
pub fn active_turn_snapshot(&self) -> Option<Turn> {
+ self.active_turn_snapshot_with_items_view(TurnItemsView::Full)
+ }
+
+ /// Snapshots the active or last finished turn, copying only the requested items.
+ pub fn active_turn_snapshot_with_items_view(&self, items_view: TurnItemsView) -> Option<Turn> {
self.current_turn
.as_ref()
- .map(Turn::from)
- .or_else(|| self.turns.last().map(Turn::from))
+ .or_else(|| self.turns.last())
+ .map(|turn| turn.snapshot(items_view))
}
/// Snapshots active turn metadata without cloning its items.
@@ -1714,6 +1719,19 @@ impl PendingTurn {
self.started_at = started_at;
self
}
+
+ fn snapshot(&self, items_view: TurnItemsView) -> Turn {
+ Turn {
+ id: self.id.clone(),
+ items: items_view.project_items(&self.items),
+ items_view,
+ error: self.error.clone(),
+ status: self.status.clone(),
+ started_at: self.started_at,
+ completed_at: self.completed_at,
+ duration_ms: self.duration_ms,
+ }
+ }
}
impl From<PendingTurn> for Turn {
@@ -1733,16 +1751,7 @@ impl From<PendingTurn> for Turn {
impl From<&PendingTurn> for Turn {
fn from(value: &PendingTurn) -> Self {
- Self {
- id: value.id.clone(),
- items: value.items.clone(),
- items_view: TurnItemsView::Full,
- error: value.error.clone(),
- status: value.status.clone(),
- started_at: value.started_at,
- completed_at: value.completed_at,
- duration_ms: value.duration_ms,
- }
+ value.snapshot(TurnItemsView::Full)
}
}
@@ -3961,6 +3970,78 @@ mod tests {
);
}
+ #[test]
+ fn active_turn_summary_preserves_selection_and_completed_metadata() {
+ let mut builder = ThreadHistoryBuilder::new();
+ assert_eq!(
+ builder.active_turn_snapshot_with_items_view(TurnItemsView::Summary),
+ None
+ );
+ builder.handle_event(&EventMsg::TurnStarted(TurnStartedEvent {
+ turn_id: "turn-1".into(),
+ root_turn_id: None,
+ trace_id: None,
+ started_at: Some(100),
+ model_context_window: None,
+ collaboration_mode_kind: Default::default(),
+ }));
+ builder.handle_event(&EventMsg::UserMessage(UserMessageEvent {
+ message: "first".into(),
+ ..Default::default()
+ }));
+ let first_user = builder.active_turn_snapshot().unwrap().items[0].clone();
+ builder.handle_event(&EventMsg::UserMessage(UserMessageEvent {
+ message: "steering".into(),
+ ..Default::default()
+ }));
+ for message in ["draft", "answer"] {
+ builder.handle_event(&EventMsg::AgentMessage(AgentMessageEvent {
+ message: message.into(),
+ phase: None,
+ memory_citation: None,
+ delivery: None,
+ questions: None,
+ }));
+ }
+ let final_agent = builder
+ .active_turn_snapshot()
+ .unwrap()
+ .items
+ .last()
+ .unwrap()
+ .clone();
+ builder.handle_event(&EventMsg::AgentReasoning(AgentReasoningEvent {
+ text: "not included in the summary".repeat(1024),
+ }));
+ let mut expected = builder.active_turn_snapshot().unwrap();
+ expected.items = vec![first_user, final_agent];
+ expected.items_view = TurnItemsView::Summary;
+ assert_eq!(
+ builder.active_turn_snapshot_with_items_view(TurnItemsView::Summary),
+ Some(expected.clone())
+ );
+ builder.handle_event(&EventMsg::TurnComplete(TurnCompleteEvent {
+ turn_id: "turn-1".into(),
+ started_at: Some(100),
+ last_agent_message: None,
+ error: None,
+ completed_at: Some(102),
+ duration_ms: Some(2_000),
+ time_to_first_token_ms: None,
+ }));
+ expected.status = TurnStatus::Completed;
+ expected.completed_at = Some(102);
+ expected.duration_ms = Some(2_000);
+ assert_eq!(
+ builder.active_turn_snapshot_with_items_view(TurnItemsView::Summary),
+ Some(expected)
+ );
+ assert_eq!(
+ builder.active_turn_snapshot_with_items_view(TurnItemsView::NotLoaded),
+ builder.active_turn_metadata_snapshot().map(Turn::from)
+ );
+ }
+
#[test]
fn active_turn_metadata_snapshot_tracks_turn_lifecycle() {
let mut builder = ThreadHistoryBuilder::new();
diff --git a/codex-rs/app-server-protocol/src/protocol/turn_items_view.rs b/codex-rs/app-server-protocol/src/protocol/turn_items_view.rs
new file mode 100644
index 0000000000..7af9fe50ce
--- /dev/null
+++ b/codex-rs/app-server-protocol/src/protocol/turn_items_view.rs
@@ -0,0 +1,33 @@
+//! Projects a turn's items without copying payloads excluded by the requested view.
+
+use super::v2::ThreadItem;
+use super::v2::TurnItemsView;
+
+impl TurnItemsView {
+ /// Copies only the items included in this view, preserving summary selection order.
+ pub fn project_items(self, items: &[ThreadItem]) -> Vec<ThreadItem> {
+ match self {
+ Self::NotLoaded => Vec::new(),
+ Self::Full => items.to_vec(),
+ Self::Summary => {
+ let first_user_message = items
+ .iter()
+ .find(|item| matches!(item, ThreadItem::UserMessage { .. }));
+ let final_agent_message = items
+ .iter()
+ .rev()
+ .find(|item| matches!(item, ThreadItem::AgentMessage { .. }));
+ match (first_user_message, final_agent_message) {
+ (Some(user_message), Some(agent_message))
+ if user_message.id() != agent_message.id() =>
+ {
+ vec![user_message.clone(), agent_message.clone()]
+ }
+ (Some(user_message), _) => vec![user_message.clone()],
+ (None, Some(agent_message)) => vec![agent_message.clone()],
+ (None, None) => Vec::new(),
+ }
+ }
+ }
+ }
+}
diff --git a/codex-rs/app-server/src/request_processors/thread_lifecycle.rs b/codex-rs/app-server/src/request_processors/thread_lifecycle.rs
index 5e7697df72..b0fa49b4ba 100644
--- a/codex-rs/app-server/src/request_processors/thread_lifecycle.rs
+++ b/codex-rs/app-server/src/request_processors/thread_lifecycle.rs
@@ -576,16 +576,16 @@ pub(super) async fn handle_pending_thread_resume_request(
) {
let (active_turn_metadata, active_turn) = {
let state = thread_state.lock().await;
- let needs_items = pending.include_turns
- || pending
+ let items_view = if pending.include_turns {
+ Some(TurnItemsView::Full)
+ } else {
+ pending
.initial_turns_page
.as_ref()
- .is_some_and(|page| !matches!(page.items_view, Some(TurnItemsView::NotLoaded)));
- let active_turn = if needs_items {
- state.active_turn_snapshot()
- } else {
- None
+ .map(|page| page.items_view.unwrap_or(TurnItemsView::Summary))
};
+ let active_turn =
+ items_view.and_then(|view| state.active_turn_snapshot_with_items_view(view));
(state.active_turn_metadata_snapshot(), active_turn)
};
tracing::debug!(
diff --git a/codex-rs/app-server/src/request_processors/thread_processor.rs b/codex-rs/app-server/src/request_processors/thread_processor.rs
index 973f05a0bb..b7affb2367 100644
--- a/codex-rs/app-server/src/request_processors/thread_processor.rs
+++ b/codex-rs/app-server/src/request_processors/thread_processor.rs
@@ -5731,39 +5731,10 @@ pub(super) fn build_thread_resume_initial_turns_page(
pub(super) fn apply_thread_turns_items_view(turns: &mut [Turn], items_view: TurnItemsView) {
for turn in turns {
- match items_view {
- TurnItemsView::NotLoaded => {
- turn.items.clear();
- turn.items_view = TurnItemsView::NotLoaded;
- }
- TurnItemsView::Summary => {
- let first_user_message = turn
- .items
- .iter()
- .find(|item| matches!(item, ThreadItem::UserMessage { .. }))
- .cloned();
- let final_agent_message = turn
- .items
- .iter()
- .rev()
- .find(|item| matches!(item, ThreadItem::AgentMessage { .. }))
- .cloned();
- turn.items = match (first_user_message, final_agent_message) {
- (Some(user_message), Some(agent_message))
- if user_message.id() != agent_message.id() =>
- {
- vec![user_message, agent_message]
- }
- (Some(user_message), _) => vec![user_message],
- (None, Some(agent_message)) => vec![agent_message],
- (None, None) => Vec::new(),
- };
- turn.items_view = TurnItemsView::Summary;
- }
- TurnItemsView::Full => {
- turn.items_view = TurnItemsView::Full;
- }
+ if !matches!(items_view, TurnItemsView::Full) && turn.items_view != items_view {
+ turn.items = items_view.project_items(&turn.items);
}
+ turn.items_view = items_view;
}
}
diff --git a/codex-rs/app-server/src/thread_state.rs b/codex-rs/app-server/src/thread_state.rs
index a02e855f0a..8cfbc00983 100644
--- a/codex-rs/app-server/src/thread_state.rs
+++ b/codex-rs/app-server/src/thread_state.rs
@@ -8,6 +8,7 @@ use codex_app_server_protocol::ThreadItem;
use codex_app_server_protocol::ThreadSettings;
use codex_app_server_protocol::Turn;
use codex_app_server_protocol::TurnError;
+use codex_app_server_protocol::TurnItemsView;
use codex_core::CodexThread;
use codex_core::ThreadConfigSnapshot;
use codex_file_watcher::WatchRegistration;
@@ -171,6 +172,14 @@ impl ThreadState {
self.current_turn_history.active_turn_id()
}
+ pub(crate) fn active_turn_snapshot_with_items_view(
+ &self,
+ items_view: TurnItemsView,
+ ) -> Option<Turn> {
+ self.current_turn_history
+ .active_turn_snapshot_with_items_view(items_view)
+ }
+
pub(crate) fn active_turn_metadata_snapshot(&self) -> Option<ThreadHistoryTurnMetadata> {
self.current_turn_history.active_turn_metadata_snapshot()
}
diff --git a/codex-rs/app-server/tests/suite/v2/thread_resume.rs b/codex-rs/app-server/tests/suite/v2/thread_resume.rs
index b31c06babe..1904431cc7 100644
--- a/codex-rs/app-server/tests/suite/v2/thread_resume.rs
+++ b/codex-rs/app-server/tests/suite/v2/thread_resume.rs
@@ -5298,15 +5298,19 @@ async fn thread_resume_rejoins_running_paginated_thread_with_initial_page() -> R
"hot paginated resume should wait for a real token usage update"
);
- for items_view in [TurnItemsView::Summary, TurnItemsView::Full] {
+ for (exclude_turns, items_view) in [
+ (true, None),
+ (true, Some(TurnItemsView::Full)),
+ (false, Some(TurnItemsView::Summary)),
+ ] {
let resume_id = primary
.send_thread_resume_request(ThreadResumeParams {
thread_id: thread.id.clone(),
- exclude_turns: true,
+ exclude_turns,
initial_turns_page: Some(ThreadResumeInitialTurnsPageParams {
limit: Some(1),
sort_direction: Some(SortDirection::Desc),
- items_view: Some(items_view),
+ items_view,
}),
..Default::default()
})
@@ -5317,8 +5321,17 @@ async fn thread_resume_rejoins_running_paginated_thread_with_initial_page() -> R
assert_eq!(page.data.len(), 1);
assert_eq!(page.data[0].id, running_turn.id);
assert_eq!(page.data[0].status, TurnStatus::InProgress);
- assert_eq!(page.data[0].items_view, items_view);
+ assert_eq!(
+ page.data[0].items_view,
+ items_view.unwrap_or(TurnItemsView::Summary)
+ );
assert!(!page.data[0].items.is_empty());
+ if !exclude_turns {
+ let full_turn = resumed.thread.turns.last().expect("full active turn");
+ assert_eq!(full_turn.id, running_turn.id);
+ assert_eq!(full_turn.items_view, TurnItemsView::Full);
+ assert!(!full_turn.items.is_empty());
+ }
}
let asc_resume_id = primary