Preserve harness metadata across conversation history (#38058)

## What changed

- Wrap response items with optional harness-owned metadata while keeping the persisted response payload shape backward compatible.
- Store compacted-history metadata in an aligned sidecar and reject malformed sidecars.
- Carry metadata through history normalization, compaction, resume, fork, truncation, migration, and rollout recording without sending it to model providers.

## Testing

- Cover legacy rollout compatibility, metadata serialization and validation, compaction retention, and resume/fork reconstruction.

GitOrigin-RevId: 17a6127c9048ff984cb4df4d97c0751a38c29f5f
This commit is contained in:
rka-oai authored and copyberry committed 2026-08-11 19:30:12 +00:00
1 parent 44d992c14e
commit 3a6f747d77
67 files changed
+2075 -655

No files matched your search

+9 -6
View File
@@ -926,12 +926,15 @@ mod tests {
phase: Some(MessagePhase::Commentary),
memory_citation: None,
})),
RolloutItem::ResponseItem(ResponseItem::FunctionCallOutput {
id: None,
call_id: "call-1".to_string(),
output: FunctionCallOutputPayload::from_text("tool output".to_string()),
internal_chat_message_metadata_passthrough: None,
}),
RolloutItem::ResponseItem(
ResponseItem::FunctionCallOutput {
id: None,
call_id: "call-1".to_string(),
output: FunctionCallOutputPayload::from_text("tool output".to_string()),
internal_chat_message_metadata_passthrough: None,
}
.into(),
),
RolloutItem::EventMsg(EventMsg::TokenCount(
codex_protocol::protocol::TokenCountEvent {
info: None,
@@ -541,15 +541,18 @@ fn turn_complete(turn_id: &str) -> RolloutItem {
}
fn user_message(message: &str) -> RolloutItem {
RolloutItem::ResponseItem(ResponseItem::Message {
id: None,
role: "user".to_string(),
content: vec![ContentItem::InputText {
text: message.to_string(),
}],
phase: None,
internal_chat_message_metadata_passthrough: None,
})
RolloutItem::ResponseItem(
ResponseItem::Message {
id: None,
role: "user".to_string(),
content: vec![ContentItem::InputText {
text: message.to_string(),
}],
phase: None,
internal_chat_message_metadata_passthrough: None,
}
.into(),
)
}
fn contextual_user_message() -> RolloutItem {
@@ -575,15 +578,18 @@ fn completed_user_message(turn_id: &str, message: &str) -> RolloutItem {
}
fn agent_message(message: &str) -> RolloutItem {
RolloutItem::ResponseItem(ResponseItem::AgentMessage {
id: None,
author: "worker".to_string(),
recipient: "root".to_string(),
content: vec![AgentMessageInputContent::InputText {
text: message.to_string(),
}],
internal_chat_message_metadata_passthrough: None,
})
RolloutItem::ResponseItem(
ResponseItem::AgentMessage {
id: None,
author: "worker".to_string(),
recipient: "root".to_string(),
content: vec![AgentMessageInputContent::InputText {
text: message.to_string(),
}],
internal_chat_message_metadata_passthrough: None,
}
.into(),
)
}
fn turn_context(root: &Path, turn_id: &str) -> RolloutItem {
@@ -614,7 +620,8 @@ fn turn_context(root: &Path, turn_id: &str) -> RolloutItem {
fn compacted(message: &str, replacement_history: Option<Vec<ResponseItem>>) -> RolloutItem {
RolloutItem::Compacted(CompactedItem {
message: message.to_string(),
replacement_history,
replacement_history: replacement_history
.map(|items| items.into_iter().map(Into::into).collect()),
window_number: Some(1),
first_window_id: None,
previous_window_id: None,
@@ -114,13 +114,13 @@ impl LegacyRolloutCanonicalizer {
let bytes_before = self.bytes_written;
match line.item {
RolloutItem::SessionMeta(_) => return Ok(0),
RolloutItem::ResponseItem(ResponseItem::Other) => {
return Err(migration_error(
"legacy rollout contains an unsupported response item",
));
}
RolloutItem::ResponseItem(response) => {
let hook = match &response {
if matches!(&response.item, ResponseItem::Other) {
return Err(migration_error(
"legacy rollout contains an unsupported response item",
));
}
let hook = match &response.item {
ResponseItem::Message {
role, content, id, ..
} if role == "user" => parse_hook_prompt_message(id.as_deref(), content),
@@ -12,6 +12,7 @@ use codex_protocol::items::parse_hook_prompt_fragment;
use codex_protocol::models::ContentItem;
use codex_protocol::models::ResponseItem;
use codex_protocol::protocol::InterAgentCommunication;
use std::borrow::Borrow;
/// Match the rollback boundaries used by legacy history reconstruction without
/// treating every persisted lifecycle as a user turn. This intentionally stays
@@ -40,14 +41,17 @@ pub(super) fn is_pre_turn_context_update(response: &ResponseItem) -> bool {
/// Apply the same response-history cut used by legacy cold resume to a persisted
/// compaction checkpoint. The migration adapter uses a frozen contextual-fragment
/// matcher because thread-store cannot depend on core's runtime fragment registry.
pub(super) fn drop_last_n_user_turns(history: &mut Vec<ResponseItem>, num_turns: u32) {
pub(super) fn drop_last_n_user_turns<T>(history: &mut Vec<T>, num_turns: u32)
where
T: Borrow<ResponseItem>,
{
if num_turns == 0 {
return;
}
let user_positions = history
.iter()
.enumerate()
.filter_map(|(index, item)| counts_as_boundary(item).then_some(index))
.filter_map(|(index, item)| counts_as_boundary(item.borrow()).then_some(index))
.collect::<Vec<_>>();
let Some(&first_turn_index) = user_positions.first() else {
return;
@@ -58,7 +62,9 @@ pub(super) fn drop_last_n_user_turns(history: &mut Vec<ResponseItem>, num_turns:
} else {
user_positions[user_positions.len() - count]
};
while cut_index > first_turn_index && is_pre_turn_context_update(&history[cut_index - 1]) {
while cut_index > first_turn_index
&& is_pre_turn_context_update(history[cut_index - 1].borrow())
{
cut_index -= 1;
}
history.truncate(cut_index);
@@ -121,7 +121,9 @@ impl RollbackPlanner {
_ => None,
};
let paired_delivery_boundary = match (&self.pending_delivery_boundary, &line.item) {
(Some(boundary), RolloutItem::ResponseItem(ResponseItem::AgentMessage { .. })) => {
(Some(boundary), RolloutItem::ResponseItem(response))
if matches!(&response.item, ResponseItem::AgentMessage { .. }) =>
{
Some(*boundary)
}
_ => None,
@@ -134,9 +136,9 @@ impl RollbackPlanner {
RolloutItem::ResponseItem(response) => {
if let Some(boundary) = paired_delivery_boundary {
self.record_boundaries[index] = Some(boundary);
} else if rollback::counts_as_boundary(response) {
} else if rollback::counts_as_boundary(&response.item) {
let boundary = self.start_boundary(index);
if let ResponseItem::Message { role, content, .. } = response
if let ResponseItem::Message { role, content, .. } = &response.item
&& role == "user"
{
self.pending_user_response = Some(PendingUserResponse {
@@ -144,7 +146,7 @@ impl RollbackPlanner {
content: content.clone(),
});
}
} else if rollback::is_pre_turn_context_update(response) {
} else if rollback::is_pre_turn_context_update(&response.item) {
// Until another user boundary arrives, this is trailing context for the
// previous turn. Keep that fallback owner so rollback drops it when there is
// no later turn to attach it to.
@@ -68,7 +68,7 @@ impl ModelReplayPlanner {
RolloutItem::TurnContext(context) => ReplayRecord::TurnContext(context.turn_id.clone()),
RolloutItem::EventMsg(EventMsg::UserMessage(_))
| RolloutItem::InterAgentCommunication(_) => ReplayRecord::UserBoundary,
RolloutItem::ResponseItem(response) if rollback::counts_as_boundary(response) => {
RolloutItem::ResponseItem(response) if rollback::counts_as_boundary(&response.item) => {
ReplayRecord::UserBoundary
}
RolloutItem::SessionMeta(_)
@@ -165,6 +165,10 @@ fn input_response_message(role: &str, text: &str) -> ResponseItem {
}
}
fn rollout_response_item(item: ResponseItem) -> RolloutItem {
RolloutItem::ResponseItem(item.into())
}
fn exec_completion(turn_id: &str, call_id: &str) -> RolloutItem {
serde_json::from_value(json!({
"type": "event_msg",
@@ -215,7 +219,7 @@ fn started(turn_id: &str) -> RolloutItem {
fn compacted(replacement_history: Vec<ResponseItem>) -> RolloutItem {
RolloutItem::Compacted(CompactedItem {
message: "checkpoint".to_string(),
replacement_history: Some(replacement_history),
replacement_history: Some(replacement_history.into_iter().map(Into::into).collect()),
window_number: Some(1),
first_window_id: None,
previous_window_id: None,
@@ -671,7 +675,7 @@ async fn migration_rolls_back_response_and_inter_agent_user_boundaries() {
response_thread_id,
SessionSource::Cli,
vec![
RolloutItem::ResponseItem(input_response_message("user", "remove response boundary")),
rollout_response_item(input_response_message("user", "remove response boundary")),
RolloutItem::EventMsg(EventMsg::ThreadRolledBack(ThreadRolledBackEvent {
num_turns: 1,
})),
@@ -703,16 +707,16 @@ async fn migration_rolls_back_response_and_inter_agent_user_boundaries() {
contextual_thread_id,
SessionSource::Cli,
vec![
RolloutItem::ResponseItem(input_response_message("user", "keep first boundary")),
RolloutItem::ResponseItem(input_response_message(
rollout_response_item(input_response_message("user", "keep first boundary")),
rollout_response_item(input_response_message(
"developer",
"<permissions instructions>context only</permissions instructions>",
)),
RolloutItem::ResponseItem(input_response_message(
rollout_response_item(input_response_message(
"user",
"<environment_context>context only</environment_context>",
)),
RolloutItem::ResponseItem(input_response_message("user", "remove real user boundary")),
rollout_response_item(input_response_message("user", "remove real user boundary")),
RolloutItem::EventMsg(EventMsg::ThreadRolledBack(ThreadRolledBackEvent {
num_turns: 1,
})),
@@ -740,7 +744,7 @@ async fn migration_rolls_back_response_and_inter_agent_user_boundaries() {
read_rollout(&contextual_path)
.into_iter()
.filter_map(|line| match line.item {
RolloutItem::ResponseItem(response) => Some(response),
RolloutItem::ResponseItem(response) => Some(response.into_item()),
_ => None,
})
.collect::<Vec<_>>(),
@@ -757,9 +761,9 @@ async fn migration_drops_trailing_context_when_rollback_arrives_before_next_turn
thread_id,
SessionSource::Cli,
vec![
RolloutItem::ResponseItem(input_response_message("user", "keep question")),
RolloutItem::ResponseItem(input_response_message("user", "remove question")),
RolloutItem::ResponseItem(input_response_message(
rollout_response_item(input_response_message("user", "keep question")),
rollout_response_item(input_response_message("user", "remove question")),
rollout_response_item(input_response_message(
"user",
"<turn_aborted>remove this context too</turn_aborted>",
)),
@@ -780,7 +784,7 @@ async fn migration_drops_trailing_context_when_rollback_arrives_before_next_turn
read_rollout(&path)
.into_iter()
.filter_map(|line| match line.item {
RolloutItem::ResponseItem(response) => Some(response),
RolloutItem::ResponseItem(response) => Some(response.into_item()),
_ => None,
})
.collect::<Vec<_>>(),
@@ -797,7 +801,7 @@ async fn migration_coalesces_response_first_user_message_rollback_boundary() {
thread_id,
SessionSource::Cli,
vec![
RolloutItem::ResponseItem(input_response_message("user", "remove question")),
rollout_response_item(input_response_message("user", "remove question")),
user_message("remove question"),
RolloutItem::EventMsg(EventMsg::ThreadRolledBack(ThreadRolledBackEvent {
num_turns: 1,
@@ -828,7 +832,7 @@ async fn migration_does_not_coalesce_distinct_adjacent_user_records() {
thread_id,
SessionSource::Cli,
vec![
RolloutItem::ResponseItem(input_response_message("user", "copied parent question")),
rollout_response_item(input_response_message("user", "copied parent question")),
user_message("child question"),
RolloutItem::EventMsg(EventMsg::ThreadRolledBack(ThreadRolledBackEvent {
num_turns: 1,
@@ -847,7 +851,7 @@ async fn migration_does_not_coalesce_distinct_adjacent_user_records() {
read_rollout(&path)
.into_iter()
.filter_map(|line| match line.item {
RolloutItem::ResponseItem(response) => Some(response),
RolloutItem::ResponseItem(response) => Some(response.into_item()),
_ => None,
})
.collect::<Vec<_>>(),
@@ -988,7 +992,7 @@ async fn migration_rolls_back_inter_agent_metadata_with_its_delivery() {
SessionSource::Cli,
vec![
RolloutItem::InterAgentCommunicationMetadata { trigger_turn: true },
RolloutItem::ResponseItem(delivery.to_model_input_item()),
rollout_response_item(delivery.to_model_input_item()),
RolloutItem::EventMsg(EventMsg::ThreadRolledBack(ThreadRolledBackEvent {
num_turns: 1,
})),
@@ -1002,12 +1006,12 @@ async fn migration_rolls_back_inter_agent_metadata_with_its_delivery() {
.await
.expect("migrate rolled-back inter-agent delivery");
assert!(!read_rollout(&path).iter().any(|line| {
matches!(
line.item,
RolloutItem::InterAgentCommunicationMetadata { .. }
| RolloutItem::ResponseItem(ResponseItem::AgentMessage { .. })
)
assert!(!read_rollout(&path).iter().any(|line| match &line.item {
RolloutItem::InterAgentCommunicationMetadata { .. } => true,
RolloutItem::ResponseItem(response_item) => {
matches!(&response_item.item, ResponseItem::AgentMessage { .. })
}
_ => false,
}));
}
@@ -1082,7 +1086,7 @@ async fn migration_preserves_reverse_replay_anchor_after_pre_compaction_rollback
thread_id,
SessionSource::Cli,
vec![
RolloutItem::ResponseItem(input_response_message("user", "remove question")),
rollout_response_item(input_response_message("user", "remove question")),
RolloutItem::EventMsg(EventMsg::ThreadRolledBack(ThreadRolledBackEvent {
num_turns: 1,
})),
@@ -1203,7 +1207,12 @@ async fn migration_uses_turn_context_to_select_reverse_replay_anchor() {
let replacement_histories = read_rollout(&path)
.into_iter()
.filter_map(|line| match line.item {
RolloutItem::Compacted(item) => item.replacement_history,
RolloutItem::Compacted(item) => item.replacement_history.map(|items| {
items
.into_iter()
.map(codex_rollout::ResponseItemEnvelope::into_item)
.collect::<Vec<_>>()
}),
_ => None,
})
.collect::<Vec<_>>();
@@ -1279,7 +1288,7 @@ async fn migration_drops_copied_user_fork_metadata_without_creating_a_history_ba
..SessionMeta::default()
};
let copied_response =
RolloutItem::ResponseItem(input_response_message("user", "copied parent history"));
rollout_response_item(input_response_message("user", "copied parent history"));
let path = write_rollout_with_fork(
home.path(),
thread_id,
@@ -1299,7 +1308,7 @@ async fn migration_drops_copied_user_fork_metadata_without_creating_a_history_ba
.into_iter()
.filter_map(|line| match line.item {
RolloutItem::ResponseItem(item) => {
Some(serde_json::to_value(item).expect("serialize copied response"))
Some(serde_json::to_value(item.item).expect("serialize copied response"))
}
_ => None,
})
@@ -1333,7 +1342,7 @@ async fn migration_drops_copied_user_fork_metadata_without_creating_a_history_ba
.into_iter()
.filter_map(|line| match line.item {
RolloutItem::ResponseItem(item) => {
Some(serde_json::to_value(item).expect("serialize migrated response"))
Some(serde_json::to_value(item.item).expect("serialize migrated response"))
}
_ => None,
})
@@ -1361,15 +1370,18 @@ async fn migration_compacts_subagent_prefix_and_does_not_project_it() {
}),
RolloutItem::Compacted(CompactedItem {
message: "latest checkpoint".to_string(),
replacement_history: Some(vec![ResponseItem::Message {
id: None,
role: "user".to_string(),
content: vec![ContentItem::InputText {
text: "latest compacted context".to_string(),
}],
phase: None,
internal_chat_message_metadata_passthrough: None,
}]),
replacement_history: Some(vec![
ResponseItem::Message {
id: None,
role: "user".to_string(),
content: vec![ContentItem::InputText {
text: "latest compacted context".to_string(),
}],
phase: None,
internal_chat_message_metadata_passthrough: None,
}
.into(),
]),
window_number: Some(2),
first_window_id: None,
previous_window_id: None,
@@ -2296,26 +2296,31 @@ fn turn_completed(turn_id: &str) -> RolloutItem {
}
fn user_message(message: &str) -> RolloutItem {
RolloutItem::ResponseItem(ResponseItem::Message {
id: None,
role: "user".to_string(),
content: vec![ContentItem::InputText {
text: message.to_string(),
}],
phase: None,
internal_chat_message_metadata_passthrough: None,
})
RolloutItem::ResponseItem(
ResponseItem::Message {
id: None,
role: "user".to_string(),
content: vec![ContentItem::InputText {
text: message.to_string(),
}],
phase: None,
internal_chat_message_metadata_passthrough: None,
}
.into(),
)
}
fn contains_user_message(items: &[RolloutItem], expected: &str) -> bool {
items.iter().any(|item| {
matches!(
item,
RolloutItem::ResponseItem(ResponseItem::Message { content, .. })
if content.iter().any(|content| {
matches!(content, ContentItem::InputText { text } if text == expected)
})
)
let RolloutItem::ResponseItem(response_item) = item else {
return false;
};
let ResponseItem::Message { content, .. } = &response_item.item else {
return false;
};
content
.iter()
.any(|content| matches!(content, ContentItem::InputText { text } if text == expected))
})
}