Files
codex/codex-rs/ext/guardian-v3/tests/evidence.rs
T
Ruslan Nigmatullin 9e6d1c5278 Preserve retained assistant revisions across rollout replay (#60839)
## Why

Replaying delivered assistant messages allocates new retained-source revisions instead of preserving those captured in live history.

## What changed

- Capture retained sources when recording assistant deliveries, persist them in rollout metadata, and reuse their revisions during replay.
- Add optional `next_item_ordinal` compaction metadata and a `next_model_id_ordinals` helper to recover item and window allocation positions from checkpoints and subsequent records. Ignore allocation metadata that refers to other threads.

## Testing

Extend tests to compare live and replayed delivery sources, preserve revisions through an older reader's rewrite, and verify ordinal recovery from checkpoints and subsequent local items.

GitOrigin-RevId: cfdeebe8e13b1700b34b9c98696880a90a99ace5
2026-11-11 18:56:47 +00:00

317 lines
12 KiB
Rust

//! Captured originals preserve attribution, complete contents and a fixed history boundary.
use codex_context_fragments::AdditionalContextUserFragment;
use codex_context_fragments::AnnotatedContent;
use codex_context_fragments::ContextualUserFragment;
use codex_context_fragments::message_from_parts;
use codex_guardian_v3::EvidenceCursor;
use codex_guardian_v3::OriginalEvidence;
use codex_history::AcceptedFileAudio;
use codex_history::CodexHarnessMetadata;
use codex_history::HistoryInitialization;
use codex_history::ResponseItemEnvelope;
use codex_history::RetainedContextEvent;
use codex_history::RetainedUserMessage;
use codex_history::RolloutItem;
use codex_history::UserInputOrigin;
use codex_history::VerifiedAnswer;
use codex_history::VerifiedQuestionAnswer;
use codex_protocol::ThreadId;
use codex_protocol::models::BaseInstructions;
use codex_protocol::models::ContentItemKind;
use codex_protocol::models::ContentItemMetadata;
use codex_protocol::protocol::SessionSource;
use codex_protocol::protocol::ThreadHistoryMode;
use codex_protocol::protocol::ThreadMemoryMode;
use codex_state::SqliteConfig;
use codex_thread_store::AppendThreadItemsParams;
use codex_thread_store::CreateThreadParams;
use codex_thread_store::LocalThreadStore;
use codex_thread_store::LocalThreadStoreConfig;
use codex_thread_store::PersistContext;
use codex_thread_store::ThreadPersistenceMetadata;
use codex_thread_store::ThreadStore;
use pretty_assertions::assert_eq;
use serde_json::json;
use std::sync::Arc;
#[tokio::test]
async fn captures_originals_without_generated_context_or_later_appends() -> anyhow::Result<()> {
let dir = tempfile::tempdir()?;
let owner = ThreadId::new();
let store = LocalThreadStore::new(
LocalThreadStoreConfig {
codex_home: dir.path().to_path_buf(),
sqlite: SqliteConfig::new_for_testing(dir.path().to_path_buf().try_into()?),
default_model_provider_id: "test-provider".into(),
},
/*state_db*/ None,
);
store
.create_thread(CreateThreadParams {
attached_thread: false,
creator_user_id: None,
creator_account_id: None,
session_id: owner.into(),
thread_id: owner,
extra_config: None,
forked_from_id: None,
parent_thread_id: None,
source: SessionSource::Exec,
thread_source: None,
originator: "test-originator".into(),
base_instructions: BaseInstructions::default(),
dynamic_tools: Vec::new(),
selected_capability_roots: Vec::new(),
multi_agent_version: None,
history_mode: ThreadHistoryMode::Paginated,
history_base: None,
subagent_history_start_ordinal: None,
initial_window_id: codex_protocol::ContextWindowId::new_uuid_v7(),
runtime_workspace_roots: None,
metadata: ThreadPersistenceMetadata {
cwd: Some(dir.path().to_path_buf()),
model_provider: "test-provider".into(),
memory_mode: ThreadMemoryMode::Disabled,
},
})
.await?;
let user = ResponseItemEnvelope {
item: serde_json::from_value(json!({"type":"message","id":"user-1","role":"user",
"content":[{"type":"input_text","text":"é🙂".repeat(15_000)}]}))?,
metadata: Some(CodexHarnessMetadata {
user_input_order: Some(1),
..Default::default()
}),
};
let assistant = ResponseItemEnvelope::new(serde_json::from_value(json!({
"type":"message","id":"assistant-1","role":"assistant",
"content":[{"type":"output_text","text":"I will inspect the directory."}]
}))?);
let call = ResponseItemEnvelope::new(serde_json::from_value(json!({
"type":"function_call","id":"call-1","call_id":"call-1","name":"shell","arguments":"{\"cmd\":\"pwd\"}"
}))?);
let result = ResponseItemEnvelope::new(serde_json::from_value(json!({
"type":"function_call_output","call_id":"call-1","output":"/workspace"
}))?);
let generated = ResponseItemEnvelope::new(ContextualUserFragment::into(
AdditionalContextUserFragment::new("environment".into(), "Generated context".into()),
));
let mut summary = assistant.clone();
summary.metadata = Some(CodexHarnessMetadata {
compaction_output: true,
..Default::default()
});
let approved_action = r#"The user has manually approved a specific action that was previously `Rejected`.
Treat this as approval to perform that exact action in the same context in which it was originally requested.
Do not assume this also authorizes similar operations with different payloads.
Approved action: {"action":{"command":"write /workspace/report.txt"},"outcome":"allowed"}"#;
let approval = ResponseItemEnvelope::new(message_from_parts(
"developer",
vec![AnnotatedContent::text(
approved_action,
ContentItemKind("guardian.approved_action".into()),
ContentItemMetadata::harness(),
)],
));
// Identical words without the host's approval annotation must not be promoted.
let ordinary_developer = ResponseItemEnvelope::new(serde_json::from_value(json!({
"type":"message","role":"developer","content":[{"type":"input_text","text":approved_action}]
}))?);
let answer = RolloutItem::RetainedContext(RetainedContextEvent::VerifiedAnswer {
answer: VerifiedAnswer {
turn_id: "turn-1".into(),
call_id: "question-1".into(),
questions: vec![VerifiedQuestionAnswer {
question: "May I publish the report?".into(),
answer: "Only the draft; do not publish the final report.".into(),
}],
},
acceptance_order: Some(2),
});
let delivered = RolloutItem::RetainedContext(RetainedContextEvent::DeliveredAssistantMessage {
retained_source: None,
message: RetainedUserMessage {
turn_id: "turn-1".into(),
message_id: Some("delivered-1".into()),
text: "I will write the draft only.".into(),
complete: true,
origin: UserInputOrigin::User,
phase: None,
},
acceptance_order: 3,
});
let response =
|item: &ResponseItemEnvelope| json!({"type":"response_item","payload":item.item});
let expected = [
json!({
"type":"response_item",
"payload":user.item,
"metadata":{"client_authored":false,"user_input_order":1}
}),
response(&assistant),
response(&call),
response(&result),
serde_json::to_value(&answer)?,
response(&approval),
json!({
"type":"response_item",
"payload":{
"type":"message","id":"delivered-1","role":"assistant",
"content":[{"type":"output_text","text":"I will write the draft only."}],
"internal_chat_message_metadata_passthrough":{"turn_id":"turn-1"}
},
"metadata":{
"client_authored":false,
"delivered_assistant_message":"codex:code-mode-delivery:v1:complete",
"user_input_order":3
}
}),
];
let mut items = vec![
RolloutItem::ResponseItem(user.clone()),
RolloutItem::ResponseItem(assistant),
RolloutItem::ResponseItem(call),
RolloutItem::ResponseItem(result),
answer,
RolloutItem::ResponseItem(approval),
delivered,
];
let fresh = EvidenceCursor::at_thread_ready(
&store,
owner,
ThreadHistoryMode::Paginated,
HistoryInitialization::New,
)
.await?;
assert!(!store.live_rollout_path(owner).await?.exists());
// A resume must establish its tail even if the rollout is missing.
assert!(
EvidenceCursor::at_thread_ready(
&store,
owner,
ThreadHistoryMode::Paginated,
HistoryInitialization::ColdResume,
)
.await
.is_err()
);
let mut old = user.clone();
old.item = serde_json::from_value(json!({"type":"message","id":"old","role":"user",
"content":[{"type":"input_text","text":"Before board activation"}]}))?;
let old = RolloutItem::ResponseItem(old);
let first_original = serde_json::to_value(&old)?;
store
.append_items(AppendThreadItemsParams {
thread_id: owner,
items: vec![old],
})
.await?;
store
.persist_thread(owner, PersistContext::Standard)
.await?;
store.flush_thread(owner).await?;
let board_originals = |records: &[OriginalEvidence]| -> serde_json::Result<Vec<_>> {
records
.iter()
.map(|record| Ok(serde_json::to_value(record)?["original"].take()))
.collect()
};
assert_eq!(
board_originals(fresh.capture(&store).await?.records())?,
[first_original]
);
let mut cursor = EvidenceCursor::at_thread_ready(
&store,
owner,
ThreadHistoryMode::Paginated,
HistoryInitialization::ColdResume,
)
.await?;
assert!(cursor.capture(&store).await?.records().is_empty());
for item in &mut items {
if let RolloutItem::ResponseItem(envelope) = item {
envelope
.metadata
.get_or_insert_default()
.sampled_through_sequence = Some(99);
}
}
items.insert(1, RolloutItem::ResponseItem(generated));
items.extend([
RolloutItem::ResponseItem(summary),
RolloutItem::ResponseItem(ordinary_developer),
RolloutItem::RetainedContext(RetainedContextEvent::AcceptedFileAudio {
evidence: Arc::new(AcceptedFileAudio {
turn_id: "turn-1".into(),
model: "test-model".into(),
provider: "test-provider".into(),
file_ids: ["file-audio-1".into()].into(),
}),
}),
]);
store
.append_items(AppendThreadItemsParams {
thread_id: owner,
items,
})
.await?;
store
.persist_thread(owner, PersistContext::Standard)
.await?;
store.flush_thread(owner).await?;
let captured = cursor.capture(&store).await?;
// Check the serialized board post, independently of the rollout serializer.
assert_eq!(board_originals(captured.records())?, expected);
let mut later = user.clone();
later.item = serde_json::from_value(json!({"type":"message","id":"user-2","role":"user",
"content":[{"type":"input_text","text":"Do not publish."}]}))?;
later.metadata = Some(CodexHarnessMetadata {
user_input_order: Some(4),
..Default::default()
});
store
.append_items(AppendThreadItemsParams {
thread_id: owner,
items: vec![RolloutItem::ResponseItem(later.clone())],
})
.await?;
store.flush_thread(owner).await?;
// Reads do not acknowledge delivery, and a later append cannot enter the old capture.
assert_eq!(cursor.pending(&captured)?.len(), expected.len());
cursor.acknowledge(&captured, /*count*/ 2)?;
assert_eq!(board_originals(cursor.pending(&captured)?)?, expected[2..]);
cursor.acknowledge(&captured, expected.len() - 2)?;
assert!(cursor.pending(&captured)?.is_empty());
let latest = cursor.capture(&store).await?;
assert_eq!(
board_originals(latest.records())?,
[json!({
"type":"response_item",
"payload":later.item,
"metadata":{"client_authored":false,"user_input_order":4}
})]
);
assert_eq!(captured.records().len(), expected.len());
cursor.acknowledge(&latest, /*count*/ 1)?;
assert!(cursor.capture(&store).await?.records().is_empty());
assert!(cursor.acknowledge(&captured, /*count*/ 0).is_err());
let mut ambiguous = later;
ambiguous.metadata = None;
store
.append_items(AppendThreadItemsParams {
thread_id: owner,
items: vec![RolloutItem::ResponseItem(ambiguous)],
})
.await?;
store.flush_thread(owner).await?;
let before = cursor.clone();
assert!(cursor.capture(&store).await.is_err());
assert_eq!(cursor, before);
store.shutdown_thread(owner).await?;
Ok(())
}