mirror of
https://github.com/openai/codex.git
synced 2026-11-21 22:50:37 +00:00
## Why Fixed retention limits could discard long user instructions or leave older sender messages out of Guardian review even when the configured elastic budget had room for them. ## What changed - Apply the configured retained-instruction entry limit when capturing and restoring user messages. Fixed-budget reviewers use the fixed retention window for both user and assistant messages. - Build elastic sender snapshots at delivery using the receiver's sender evidence budget. Give recent user messages first claim on space, then include preceding assistant context where it fits. Mark omitted evidence and save the snapshot for review and rollback. ## Testing Add coverage for cross-host delivery after compaction, large sender snapshots through checkpoint restore and rollback, and how synchronous and asynchronous reviewers read saved or empty sender snapshots. GitOrigin-RevId: f0b01a2d558e3286335efac85a4f8645dd9b954b
1489 lines
53 KiB
Rust
1489 lines
53 KiB
Rust
use anyhow::Result;
|
|
use codex_protocol::ContextWindowId;
|
|
use codex_protocol::models::AudioReference;
|
|
use codex_protocol::models::ConfigurationReasoning;
|
|
use codex_protocol::models::PermissionProfile;
|
|
use codex_protocol::openai_models::ReasoningEffort;
|
|
use codex_protocol::permissions::FileSystemAccessMode;
|
|
use codex_protocol::permissions::FileSystemPath;
|
|
use codex_protocol::permissions::FileSystemSandboxEntry;
|
|
use codex_protocol::permissions::FileSystemSandboxPolicy;
|
|
use codex_protocol::permissions::NetworkSandboxPolicy;
|
|
use codex_protocol::protocol::ThreadSettingsSnapshot;
|
|
use codex_thread_context_ids_test_support::thread_context_ids;
|
|
use pretty_assertions::assert_eq;
|
|
use serde_json::json;
|
|
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn accepted_realtime_input_projects_from_the_canonical_response_item() -> Result<()> {
|
|
let mut item: ResponseItem = serde_json::from_value(json!({
|
|
"type": "message",
|
|
"id": "msg_input_123",
|
|
"role": "user",
|
|
"content": [{"type": "input_text", "text": "use the smaller logo"}]
|
|
}))?;
|
|
item.set_turn_id_if_missing("turn-1");
|
|
let rollout = RolloutItem::ResponseItem(ResponseItemEnvelope {
|
|
item,
|
|
metadata: Some(CodexHarnessMetadata {
|
|
realtime_handoff: Some(Box::new(RealtimeHandoffMetadata {
|
|
event_id: "receipt-1".to_string(),
|
|
realtime_session_id: "call-1".to_string(),
|
|
observed_at_ms: 42,
|
|
handoff_id: "handoff-1".to_string(),
|
|
mode: RealtimeHandoffMode::Start,
|
|
source_event_ids: vec!["frame-1".to_string()],
|
|
})),
|
|
..Default::default()
|
|
}),
|
|
});
|
|
let persisted = serde_json::to_value(&rollout)?;
|
|
assert_eq!(persisted["type"], "response_item");
|
|
assert_eq!(
|
|
persisted["payload"]["content"][0]["text"],
|
|
"use the smaller logo"
|
|
);
|
|
assert_eq!(
|
|
persisted["metadata"]["realtime_handoff"]["event_id"],
|
|
"receipt-1"
|
|
);
|
|
let restored: RolloutItem = serde_json::from_value(persisted)?;
|
|
assert_eq!(
|
|
restored.realtime_item().map(Cow::into_owned),
|
|
Some(RealtimeItem {
|
|
id: "receipt-1".to_string(),
|
|
realtime_session_id: "call-1".to_string(),
|
|
observed_at_ms: Some(42),
|
|
content: RealtimeItemContent::TurnInputAccepted {
|
|
handoff_id: "handoff-1".to_string(),
|
|
turn_id: "turn-1".to_string(),
|
|
mode: RealtimeHandoffMode::Start,
|
|
source_event_ids: vec!["frame-1".to_string()],
|
|
input_item_id: "msg_input_123".to_string(),
|
|
input: "use the smaller logo".to_string(),
|
|
},
|
|
})
|
|
);
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn transcript_chunk_projects_from_its_only_model_input() -> Result<()> {
|
|
let mut item: ResponseItem = serde_json::from_value(json!({
|
|
"type": "message", "id": "msg_chunk", "role": "user",
|
|
"content": [{"type": "input_text", "text": "user: hello"}]
|
|
}))?;
|
|
item.set_turn_id_if_missing("turn-1");
|
|
let rollout = RolloutItem::ResponseItem(ResponseItemEnvelope {
|
|
item,
|
|
metadata: Some(CodexHarnessMetadata {
|
|
realtime_session_input: Some(Box::new(RealtimeSessionInputMetadata {
|
|
event_id: "receipt-1".to_string(),
|
|
realtime_session_id: "call-1".to_string(),
|
|
observed_at_ms: 42,
|
|
source_event_ids: vec!["frame-1".to_string()],
|
|
})),
|
|
..Default::default()
|
|
}),
|
|
});
|
|
let persisted = serde_json::to_value(&rollout)?;
|
|
assert_eq!(persisted["type"], "response_item");
|
|
assert_eq!(persisted["payload"]["content"][0]["text"], "user: hello");
|
|
assert_eq!(
|
|
rollout.realtime_item().map(Cow::into_owned),
|
|
Some(RealtimeItem {
|
|
id: "receipt-1".to_string(),
|
|
realtime_session_id: "call-1".to_string(),
|
|
observed_at_ms: Some(42),
|
|
content: RealtimeItemContent::SessionInputSaved {
|
|
reason: SessionInputReason::Chunk,
|
|
source_event_ids: vec!["frame-1".to_string()],
|
|
input_item_id: "msg_chunk".to_string(),
|
|
input: "user: hello".to_string(),
|
|
},
|
|
})
|
|
);
|
|
Ok(())
|
|
}
|
|
|
|
fn thread_settings_snapshot(disabled_plugin_ids: Vec<String>) -> Result<ThreadSettingsSnapshot> {
|
|
Ok(serde_json::from_value(json!({
|
|
"model": "gpt-5",
|
|
"model_provider_id": "openai",
|
|
"approval_policy": "never",
|
|
"approvals_reviewer": "user",
|
|
"permission_profile": codex_protocol::models::PermissionProfile::read_only(),
|
|
"cwd": std::env::current_dir()?,
|
|
"collaboration_mode": {
|
|
"mode": "default",
|
|
"settings": {
|
|
"model": "gpt-5",
|
|
"reasoning_effort": null,
|
|
"developer_instructions": null
|
|
}
|
|
},
|
|
"disabled_plugin_ids": disabled_plugin_ids
|
|
}))?)
|
|
}
|
|
|
|
#[test]
|
|
fn latest_thread_settings_preserve_owned_updates_and_clears() -> Result<()> {
|
|
let thread_id = ThreadId::new();
|
|
let ancestor_id = ThreadId::new();
|
|
let mut selected = thread_settings_snapshot(vec!["example@marketplace".to_string()])?;
|
|
const RECORD_BYTES: usize = 4_096;
|
|
let policy = codex_protocol::protocol::GuardianRetentionPolicy {
|
|
assistant_record_bytes: Some(RECORD_BYTES),
|
|
user_record_bytes: None,
|
|
};
|
|
selected.guardian_retention = Some(policy);
|
|
let cleared = thread_settings_snapshot(Vec::new())?;
|
|
let item = |thread_id, thread_settings| {
|
|
RolloutItem::EventMsg(EventMsg::ThreadSettingsApplied(
|
|
codex_protocol::protocol::ThreadSettingsAppliedEvent {
|
|
thread_id,
|
|
thread_settings,
|
|
},
|
|
))
|
|
};
|
|
let foreign_items = vec![
|
|
item(Some(ancestor_id), selected.clone()),
|
|
item(/*thread_id*/ None, selected.clone()),
|
|
];
|
|
assert_eq!(latest_disabled_plugin_ids(&foreign_items, thread_id), None);
|
|
|
|
let saved_settings = serde_json::to_value(item(Some(thread_id), selected.clone()))?;
|
|
let mut history = vec![serde_json::from_value(saved_settings)?];
|
|
history.extend(foreign_items.clone());
|
|
assert_eq!(
|
|
latest_disabled_plugin_ids(&history, thread_id),
|
|
Some(selected.disabled_plugin_ids.as_slice())
|
|
);
|
|
assert_eq!(
|
|
MessageRetention::saved(&history, thread_id),
|
|
Some(MessageRetention { thread_id, policy })
|
|
);
|
|
|
|
history.push(item(Some(thread_id), cleared.clone()));
|
|
history.extend(foreign_items);
|
|
history.push(turn_context_with_disabled_plugins(Some(
|
|
selected.disabled_plugin_ids,
|
|
))?);
|
|
assert_eq!(
|
|
latest_disabled_plugin_ids(&history, thread_id),
|
|
Some(cleared.disabled_plugin_ids.as_slice())
|
|
);
|
|
assert_eq!(MessageRetention::saved(&history, thread_id), None);
|
|
Ok(())
|
|
}
|
|
|
|
fn turn_context_with_disabled_plugins(
|
|
disabled_plugin_ids: Option<Vec<String>>,
|
|
) -> Result<RolloutItem> {
|
|
let mut context: TurnContextItem = serde_json::from_value(json!({
|
|
"cwd": std::env::current_dir()?,
|
|
"approval_policy": "never",
|
|
"sandbox_policy": { "type": "danger-full-access" },
|
|
"model": "gpt-5",
|
|
"summary": "auto"
|
|
}))?;
|
|
context.disabled_plugin_ids = disabled_plugin_ids;
|
|
Ok(RolloutItem::TurnContext(context))
|
|
}
|
|
|
|
#[test]
|
|
fn latest_disabled_plugin_ids_falls_back_only_to_latest_turn_context() -> Result<()> {
|
|
let thread_id = ThreadId::new();
|
|
let selected = vec!["example@marketplace".to_string()];
|
|
let mut history = vec![turn_context_with_disabled_plugins(Some(selected.clone()))?];
|
|
assert_eq!(
|
|
latest_disabled_plugin_ids(&history, thread_id),
|
|
Some(selected.as_slice())
|
|
);
|
|
|
|
history.push(RolloutItem::EventMsg(EventMsg::ThreadSettingsApplied(
|
|
codex_protocol::protocol::ThreadSettingsAppliedEvent {
|
|
thread_id: Some(ThreadId::new()),
|
|
thread_settings: thread_settings_snapshot(Vec::new())?,
|
|
},
|
|
)));
|
|
assert_eq!(
|
|
latest_disabled_plugin_ids(&history, thread_id),
|
|
Some(selected.as_slice())
|
|
);
|
|
|
|
let cleared = Vec::new();
|
|
history.push(turn_context_with_disabled_plugins(Some(cleared.clone()))?);
|
|
assert_eq!(
|
|
latest_disabled_plugin_ids(&history, thread_id),
|
|
Some(cleared.as_slice())
|
|
);
|
|
|
|
history.push(turn_context_with_disabled_plugins(
|
|
/*disabled_plugin_ids*/ None,
|
|
)?);
|
|
assert_eq!(latest_disabled_plugin_ids(&history, thread_id), None);
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn older_thread_settings_snapshot_defaults_disabled_plugins_to_empty() -> Result<()> {
|
|
let expected = thread_settings_snapshot(Vec::new())?;
|
|
let mut legacy = serde_json::to_value(&expected)?;
|
|
legacy
|
|
.as_object_mut()
|
|
.unwrap()
|
|
.remove("disabled_plugin_ids");
|
|
|
|
assert_eq!(
|
|
serde_json::from_value::<ThreadSettingsSnapshot>(legacy)?,
|
|
expected
|
|
);
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn response_item_envelope_accessors_preserve_item() {
|
|
let expected_item = ResponseItem::Message {
|
|
status: None,
|
|
encrypted_content: None,
|
|
id: None,
|
|
role: "user".to_string(),
|
|
content: vec![ContentItem::InputText {
|
|
text: "hello".to_string(),
|
|
}],
|
|
phase: None,
|
|
internal_chat_message_metadata_passthrough: None,
|
|
};
|
|
let mut envelope = ResponseItemEnvelope::new(expected_item.clone());
|
|
|
|
assert_eq!(&*envelope, &expected_item);
|
|
let borrowed: &ResponseItem = envelope.borrow();
|
|
assert_eq!(borrowed, &expected_item);
|
|
let replacement_item = ResponseItem::Message {
|
|
status: None,
|
|
encrypted_content: None,
|
|
id: None,
|
|
role: "assistant".to_string(),
|
|
content: vec![ContentItem::OutputText {
|
|
annotations: None,
|
|
logprobs: None,
|
|
text: "goodbye".to_string(),
|
|
}],
|
|
phase: None,
|
|
internal_chat_message_metadata_passthrough: None,
|
|
};
|
|
*envelope = replacement_item.clone();
|
|
|
|
assert_eq!(envelope.into_item(), replacement_item);
|
|
}
|
|
|
|
#[test]
|
|
/// Keeps legacy response-item rollout lines readable and byte-shape compatible.
|
|
fn response_item_rollout_line_preserves_shape() -> Result<()> {
|
|
let legacy_line = json!({
|
|
"timestamp": "2025-01-03T12:00:00.000Z",
|
|
"ordinal": 7,
|
|
"type": "response_item",
|
|
"payload": {
|
|
"type": "message",
|
|
"role": "user",
|
|
"content": [{
|
|
"type": "input_text",
|
|
"text": "hello",
|
|
}],
|
|
},
|
|
});
|
|
|
|
let line = RolloutLine {
|
|
timestamp: "2025-01-03T12:00:00.000Z".to_string(),
|
|
ordinal: Some(7),
|
|
item: serde_json::from_value(legacy_line.clone())?,
|
|
};
|
|
let RolloutItem::ResponseItem(envelope) = &line.item else {
|
|
panic!("expected response item");
|
|
};
|
|
assert!(matches!(&envelope.item, ResponseItem::Message { .. }));
|
|
assert_eq!(envelope.metadata, None);
|
|
assert_eq!(serde_json::to_value(line)?, legacy_line);
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn rollout_ids_preserve_allocations_but_responses_ids_are_strings() -> Result<()> {
|
|
for (rendered, allocation) in [
|
|
("msg_item042", None),
|
|
(
|
|
"msg_item042",
|
|
Some(json!({"prefix":"msg","salt":"item","ordinal":9,"value":42})),
|
|
),
|
|
(
|
|
"item042_2",
|
|
Some(json!({"salt":"item","ordinal":17,"value":42,"suffix":"_2"})),
|
|
),
|
|
(
|
|
"provider-output-2",
|
|
Some(json!({"salt":"item","ordinal":17,"value":42})),
|
|
),
|
|
] {
|
|
let with_allocation = |mut payload: serde_json::Value| {
|
|
if let Some(allocation) = &allocation {
|
|
payload["id_allocation"] = allocation.clone();
|
|
}
|
|
payload
|
|
};
|
|
let raw = json!({"type":"message","role":"assistant","content":[],"id":rendered});
|
|
let payload = with_allocation(raw.clone());
|
|
let wire = json!({"type":"response_item","payload":payload});
|
|
let record: RolloutItem = serde_json::from_value(wire.clone())?;
|
|
assert_eq!(serde_json::to_value(&record)?, wire);
|
|
let RolloutItem::ResponseItem(envelope) = record else {
|
|
panic!("expected response item")
|
|
};
|
|
let id = envelope.item.id().expect("item ID");
|
|
assert_eq!(id.as_str(), rendered);
|
|
assert_eq!(serde_json::to_value(id.allocation())?, json!(allocation));
|
|
assert_eq!(serde_json::to_value(&envelope.item)?, raw);
|
|
let caller_item: ResponseItem = serde_json::from_value(payload.clone())?;
|
|
assert_eq!(caller_item.id().expect("wire ID").allocation(), None);
|
|
|
|
let raw_message = json!({
|
|
"author":"/root","recipient":"/root/child","other_recipients":[],
|
|
"content":"hello","trigger_turn":false,"id":rendered
|
|
});
|
|
let agent_message = json!({"type":"inter_agent_communication","payload":with_allocation(raw_message.clone())});
|
|
let record: RolloutItem = serde_json::from_value(agent_message.clone())?;
|
|
assert_eq!(serde_json::to_value(&record)?, agent_message);
|
|
let RolloutItem::InterAgentCommunication(message) = record else {
|
|
unreachable!()
|
|
};
|
|
assert_eq!(serde_json::to_value(message)?, raw_message);
|
|
|
|
let stored_id = match &allocation {
|
|
Some(allocation) => json!({"id":rendered,"id_allocation":allocation}),
|
|
None => json!(rendered),
|
|
};
|
|
let source = json!({
|
|
"id": {"message_id":"message", "turn_id":"turn", "role":"assistant"},
|
|
"revision": stored_id,
|
|
"complete": true
|
|
});
|
|
let metadata: CodexHarnessMetadata = serde_json::from_value(json!({
|
|
"guardian_review_ids": [stored_id], "retained_source": source,
|
|
"guardian_sources": [source]
|
|
}))?;
|
|
let saved = serde_json::to_value(metadata)?;
|
|
assert_eq!(saved["guardian_review_ids"], json!([stored_id]));
|
|
assert_eq!(saved["retained_source"], source);
|
|
assert_eq!(saved["guardian_sources"], json!([source]));
|
|
|
|
let compacted: CompactedItem = serde_json::from_value(json!({
|
|
"message":"summary",
|
|
"replacement_history":[payload],
|
|
"guardian_history":[payload],
|
|
}))?;
|
|
let checkpoint = serde_json::to_value(compacted)?;
|
|
assert_eq!(&checkpoint["replacement_history"][0], &payload);
|
|
assert_eq!(&checkpoint["guardian_history"][0], &payload);
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn delivered_assistant_rollout_survives_an_earlier_read_and_rewrite() -> Result<()> {
|
|
#[derive(serde::Serialize, serde::Deserialize)]
|
|
#[serde(tag = "type", rename_all = "snake_case")]
|
|
enum EarlierRolloutItem {
|
|
ResponseItem {
|
|
payload: ResponseItem,
|
|
metadata: CodexHarnessMetadata,
|
|
},
|
|
}
|
|
|
|
for complete in [true, false] {
|
|
let mut original = RetainedContextEvent::DeliveredAssistantMessage {
|
|
retained_source: None,
|
|
message: RetainedUserMessage {
|
|
origin: crate::UserInputOrigin::User,
|
|
turn_id: "root-turn".to_owned(),
|
|
message_id: Some("code-cell:message".to_owned()),
|
|
text: "May I deploy staging?".to_owned(),
|
|
complete,
|
|
phase: None,
|
|
},
|
|
acceptance_order: 7,
|
|
};
|
|
let ids = thread_context_ids();
|
|
let mut live = RetainedContext::default();
|
|
assert!(live.record_and_capture(&mut original, &ids));
|
|
let wire = serde_json::to_value(RolloutItem::RetainedContext(original.clone()))?;
|
|
let earlier = serde_json::from_value::<EarlierRolloutItem>(wire)?;
|
|
let EarlierRolloutItem::ResponseItem { payload, metadata } = &earlier;
|
|
let ResponseItem::Message {
|
|
role,
|
|
content,
|
|
phase,
|
|
..
|
|
} = payload
|
|
else {
|
|
panic!("older readers need an assistant message");
|
|
};
|
|
assert_eq!(role, "assistant");
|
|
// The preceding client's Guardian projection excludes commentary.
|
|
assert_eq!(phase, &None);
|
|
assert_eq!(metadata.user_input_order, Some(7));
|
|
let [ContentItem::OutputText { text, .. }] = content.as_slice() else {
|
|
panic!("older readers need plain assistant text");
|
|
};
|
|
if complete {
|
|
assert_eq!(text, "May I deploy staging?");
|
|
} else {
|
|
assert!(!text.contains("deploy staging"));
|
|
assert!(text.contains("unavailable"));
|
|
}
|
|
let mut earlier_checkpoint = RetainedContext::default();
|
|
earlier_checkpoint.record_assistant_message(
|
|
RetainedUserMessage {
|
|
origin: crate::UserInputOrigin::User,
|
|
turn_id: payload.turn_id().unwrap().to_owned(),
|
|
message_id: payload.id().map(ToString::to_string),
|
|
text: text.clone(),
|
|
complete: true,
|
|
phase: None,
|
|
},
|
|
RetainedInputSource::Local(metadata.user_input_order),
|
|
&thread_context_ids(),
|
|
);
|
|
let rewritten_checkpoint =
|
|
serde_json::from_value(serde_json::to_value(earlier_checkpoint)?)?;
|
|
let mut restored_checkpoint = RetainedContext::default();
|
|
restored_checkpoint.restore(Some(&rewritten_checkpoint), &[]);
|
|
let preserved = restored_checkpoint
|
|
.ordered_entries()
|
|
.find_map(|(_, entry)| match entry {
|
|
RetainedContextEntry::AssistantMessage(message) => Some(message.text.as_str()),
|
|
_ => None,
|
|
});
|
|
assert_eq!(preserved, Some(text.as_str()));
|
|
|
|
let rewritten = serde_json::to_value(earlier)?;
|
|
let RolloutItem::RetainedContext(restored) = serde_json::from_value(rewritten)? else {
|
|
panic!("new readers need the model-invisible delivery event");
|
|
};
|
|
assert_eq!(restored, original);
|
|
let mut replayed = RetainedContext::default();
|
|
assert!(replayed.record(&restored, &thread_context_ids()));
|
|
assert_eq!(replayed, live);
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
/// Keeps harness metadata beside, rather than inside, response-item payloads.
|
|
fn response_item_envelope_stores_metadata_beside_rollout_payload() -> Result<()> {
|
|
let response_item = response_message("developer");
|
|
let line = RolloutLine {
|
|
timestamp: "2025-01-03T12:00:00.000Z".to_string(),
|
|
ordinal: Some(7),
|
|
item: RolloutItem::ResponseItem(ResponseItemEnvelope {
|
|
item: response_item.clone(),
|
|
metadata: Some(CodexHarnessMetadata {
|
|
history_sequence: Some(9),
|
|
sampled_through_sequence: Some(7),
|
|
client_authored: true,
|
|
history_truncation_token_limit: Some(20_000),
|
|
inherited_user_message: true,
|
|
..Default::default()
|
|
}),
|
|
}),
|
|
};
|
|
let serialized = serde_json::to_value(&line)?;
|
|
|
|
assert_eq!(
|
|
serialized,
|
|
json!({
|
|
"timestamp": "2025-01-03T12:00:00.000Z",
|
|
"ordinal": 7,
|
|
"type": "response_item",
|
|
"payload": response_item,
|
|
"metadata": {
|
|
"history_sequence": 9,
|
|
"sampled_through_sequence": 7,
|
|
"client_authored": true,
|
|
"fallback_token_limit_override": 20_000,
|
|
"inherited_user_message": true,
|
|
},
|
|
})
|
|
);
|
|
assert_eq!(serialized["payload"].get("metadata"), None);
|
|
|
|
let restored = serde_json::from_value(serialized)?;
|
|
let RolloutItem::ResponseItem(envelope) = restored else {
|
|
panic!("expected response item");
|
|
};
|
|
assert_eq!(
|
|
envelope.metadata,
|
|
Some(CodexHarnessMetadata {
|
|
history_sequence: Some(9),
|
|
sampled_through_sequence: Some(7),
|
|
client_authored: true,
|
|
history_truncation_token_limit: Some(20_000),
|
|
inherited_user_message: true,
|
|
..Default::default()
|
|
})
|
|
);
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn response_item_envelope_preserves_harness_authored_configuration_provenance() -> Result<()> {
|
|
let response_item = ResponseItem::ConfigurationUpdate {
|
|
reasoning: ConfigurationReasoning {
|
|
effort: ReasoningEffort::High,
|
|
},
|
|
};
|
|
let metadata = CodexHarnessMetadata {
|
|
harness_authored_configuration: true,
|
|
..Default::default()
|
|
};
|
|
let rollout_item = RolloutItem::ResponseItem(ResponseItemEnvelope {
|
|
item: response_item.clone(),
|
|
metadata: Some(metadata.clone()),
|
|
});
|
|
|
|
let serialized = serde_json::to_value(&rollout_item)?;
|
|
assert_eq!(
|
|
serialized,
|
|
json!({
|
|
"type": "response_item",
|
|
"payload": {
|
|
"type": "configuration_update",
|
|
"reasoning": { "effort": "high" },
|
|
},
|
|
"metadata": {
|
|
"client_authored": false,
|
|
"harness_authored_configuration": true,
|
|
},
|
|
})
|
|
);
|
|
|
|
let restored = serde_json::from_value::<RolloutItem>(serialized)?;
|
|
let RolloutItem::ResponseItem(envelope) = restored else {
|
|
panic!("expected response item");
|
|
};
|
|
assert_eq!(
|
|
envelope,
|
|
ResponseItemEnvelope {
|
|
item: response_item,
|
|
metadata: Some(metadata),
|
|
}
|
|
);
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
/// Keeps future metadata fields from making older binaries reject persisted items.
|
|
fn response_item_envelope_ignores_unknown_harness_metadata_fields() -> Result<()> {
|
|
let line = serde_json::from_value(json!({
|
|
"timestamp": "2025-01-03T12:00:00.000Z",
|
|
"ordinal": 7,
|
|
"type": "response_item",
|
|
"payload": {
|
|
"type": "message",
|
|
"role": "user",
|
|
"content": [{
|
|
"type": "input_text",
|
|
"text": "hello",
|
|
}],
|
|
},
|
|
"metadata": {
|
|
"future_field": "value",
|
|
},
|
|
}))?;
|
|
|
|
let RolloutItem::ResponseItem(envelope) = line else {
|
|
panic!("expected response item");
|
|
};
|
|
assert_eq!(envelope.metadata, Some(CodexHarnessMetadata::default()));
|
|
|
|
let compacted = serde_json::from_value::<CompactedItem>(json!({
|
|
"message": "summary",
|
|
"replacement_history": [response_message("user")],
|
|
"replacement_history_metadata": [{ "future_field": "value" }],
|
|
}))?;
|
|
assert_eq!(
|
|
compacted.replacement_history.expect("replacement history")[0].metadata,
|
|
Some(CodexHarnessMetadata::default())
|
|
);
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
/// Keeps legacy compacted replacement histories readable while adding nullable checkpoints.
|
|
fn response_item_replacement_history_accepts_legacy_shape() -> Result<()> {
|
|
let legacy_item = json!({
|
|
"message": "summary",
|
|
"replacement_history": [{
|
|
"type": "message",
|
|
"role": "user",
|
|
"content": [{
|
|
"type": "input_text",
|
|
"text": "hello",
|
|
}],
|
|
}],
|
|
});
|
|
|
|
let item = serde_json::from_value::<CompactedItem>(legacy_item.clone())?;
|
|
let replacement_history = item
|
|
.replacement_history
|
|
.as_ref()
|
|
.expect("replacement history");
|
|
assert!(matches!(
|
|
&replacement_history[0].item,
|
|
ResponseItem::Message { .. }
|
|
));
|
|
assert_eq!(replacement_history[0].metadata, None);
|
|
let mut expected_item = legacy_item;
|
|
expected_item["compaction_response_id"] = json!(null);
|
|
expected_item["latest_token_usage_record"] = json!(null);
|
|
assert_eq!(serde_json::to_value(item)?, expected_item);
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
/// Stores complete aligned checkpoint metadata without modifying response items.
|
|
fn compacted_replacement_history_stores_metadata_in_an_aligned_sidecar() -> Result<()> {
|
|
let developer_message = response_message("developer");
|
|
let compaction_item = ResponseItem::Compaction {
|
|
id: None,
|
|
encrypted_content: "opaque".to_string(),
|
|
internal_chat_message_metadata_passthrough: None,
|
|
};
|
|
let item = CompactedItem {
|
|
message: "summary".to_string(),
|
|
replacement_history: Some(vec![
|
|
ResponseItemEnvelope {
|
|
item: developer_message.clone(),
|
|
metadata: Some(CodexHarnessMetadata {
|
|
client_authored: true,
|
|
..Default::default()
|
|
}),
|
|
},
|
|
ResponseItemEnvelope::new(compaction_item.clone()),
|
|
]),
|
|
retained_context: None,
|
|
guardian_history: None,
|
|
mcp_resource_origins: None,
|
|
window_number: None,
|
|
first_window_id: None,
|
|
previous_window_id: None,
|
|
window_id: None,
|
|
compaction_response_id: None,
|
|
latest_token_usage_record: None,
|
|
resume_metadata: None,
|
|
};
|
|
|
|
let serialized = serde_json::to_value(item)?;
|
|
assert_eq!(
|
|
serialized,
|
|
json!({
|
|
"message": "summary",
|
|
"replacement_history": [developer_message, compaction_item],
|
|
"replacement_history_metadata": [
|
|
{ "client_authored": true },
|
|
{ "client_authored": false },
|
|
],
|
|
"compaction_response_id": null,
|
|
"latest_token_usage_record": null,
|
|
})
|
|
);
|
|
|
|
let restored = serde_json::from_value::<CompactedItem>(serialized)?;
|
|
assert_eq!(
|
|
restored.replacement_history,
|
|
Some(vec![
|
|
ResponseItemEnvelope {
|
|
item: developer_message,
|
|
metadata: Some(CodexHarnessMetadata {
|
|
client_authored: true,
|
|
..Default::default()
|
|
}),
|
|
},
|
|
ResponseItemEnvelope {
|
|
item: compaction_item,
|
|
metadata: Some(CodexHarnessMetadata::default()),
|
|
},
|
|
])
|
|
);
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn compacted_resume_metadata_presence_round_trips_empty_values() -> Result<()> {
|
|
let resume_metadata = CompactionResumeMetadata {
|
|
next_item_ordinal: None,
|
|
rejected_audio_file_ids: Default::default(),
|
|
dynamic_tools: None,
|
|
observation_clock_floor_ms: None,
|
|
multi_agent_version: None,
|
|
last_started_turn_id: None,
|
|
turn_attribution: None,
|
|
previous_turn_settings: None,
|
|
};
|
|
let item = CompactedItem {
|
|
message: "summary".to_string(),
|
|
replacement_history: None,
|
|
retained_context: None,
|
|
guardian_history: None,
|
|
mcp_resource_origins: None,
|
|
window_number: None,
|
|
first_window_id: None,
|
|
previous_window_id: None,
|
|
window_id: None,
|
|
compaction_response_id: None,
|
|
latest_token_usage_record: None,
|
|
resume_metadata: Some(resume_metadata.clone()),
|
|
};
|
|
|
|
let serialized = serde_json::to_value(&item)?;
|
|
assert_eq!(serialized["resume_metadata"], json!(resume_metadata));
|
|
assert_eq!(serde_json::from_value::<CompactedItem>(serialized)?, item);
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
/// Rejects checkpoint sidecars that cannot be paired unambiguously with history.
|
|
fn compacted_replacement_history_rejects_misaligned_metadata() {
|
|
let malformed_items = [
|
|
json!({
|
|
"message": "summary",
|
|
"replacement_history": [response_message("user")],
|
|
"replacement_history_metadata": [],
|
|
}),
|
|
json!({
|
|
"message": "summary",
|
|
"replacement_history": [response_message("user")],
|
|
"replacement_history_metadata": [{}, {}],
|
|
}),
|
|
json!({
|
|
"message": "summary",
|
|
"replacement_history_metadata": [{}],
|
|
}),
|
|
];
|
|
|
|
for malformed in malformed_items {
|
|
let error = serde_json::from_value::<CompactedItem>(malformed)
|
|
.expect_err("misaligned checkpoint metadata must be rejected");
|
|
assert!(
|
|
error.to_string().contains("replacement_history_metadata"),
|
|
"error: {error}"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
/// Keeps annotated checkpoints readable by binaries expecting raw response items.
|
|
fn compacted_metadata_remains_compatible_with_legacy_response_item_readers() -> Result<()> {
|
|
#[derive(Deserialize)]
|
|
#[serde(tag = "type", content = "payload", rename_all = "snake_case")]
|
|
enum LegacyRolloutItem {
|
|
ResponseItem(Box<ResponseItem>),
|
|
Compacted(LegacyCompactedItem),
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
struct LegacyCompactedItem {
|
|
replacement_history: Vec<ResponseItem>,
|
|
}
|
|
|
|
let response_item = response_message("developer");
|
|
let envelope = ResponseItemEnvelope {
|
|
item: response_item.clone(),
|
|
metadata: Some(CodexHarnessMetadata {
|
|
client_authored: true,
|
|
..Default::default()
|
|
}),
|
|
};
|
|
let response_line = serde_json::to_value(RolloutItem::ResponseItem(envelope.clone()))?;
|
|
let LegacyRolloutItem::ResponseItem(legacy_response) =
|
|
serde_json::from_value::<LegacyRolloutItem>(response_line)?
|
|
else {
|
|
panic!("expected legacy response item");
|
|
};
|
|
assert_eq!(*legacy_response, response_item);
|
|
|
|
let checkpoint = crate::GuardianHistoryCheckpoint(vec![envelope.clone()]);
|
|
assert_eq!(
|
|
serde_json::from_value::<Vec<ResponseItem>>(serde_json::to_value(&checkpoint)?)?,
|
|
vec![response_item.clone()],
|
|
);
|
|
assert_eq!(
|
|
serde_json::from_value::<crate::GuardianHistoryCheckpoint>(serde_json::to_value(vec![
|
|
response_item.clone()
|
|
])?)?,
|
|
crate::GuardianHistoryCheckpoint(vec![response_item.clone().into()]),
|
|
);
|
|
let compacted_line = serde_json::to_value(RolloutItem::Compacted(Box::new(CompactedItem {
|
|
message: "summary".to_string(),
|
|
replacement_history: Some(vec![envelope]),
|
|
retained_context: None,
|
|
guardian_history: Some(checkpoint.clone()),
|
|
mcp_resource_origins: Some(McpResourceOriginCheckpoint::default()),
|
|
window_number: None,
|
|
first_window_id: None,
|
|
previous_window_id: None,
|
|
window_id: None,
|
|
compaction_response_id: None,
|
|
latest_token_usage_record: None,
|
|
resume_metadata: Some(CompactionResumeMetadata {
|
|
next_item_ordinal: None,
|
|
rejected_audio_file_ids: Default::default(),
|
|
dynamic_tools: None,
|
|
observation_clock_floor_ms: None,
|
|
multi_agent_version: Some(MultiAgentVersion::V2),
|
|
last_started_turn_id: Some("turn-1".to_string()),
|
|
turn_attribution: None,
|
|
previous_turn_settings: None,
|
|
}),
|
|
})))?;
|
|
|
|
let restored: RolloutItem = serde_json::from_value(compacted_line.clone())?;
|
|
let RolloutItem::Compacted(restored) = restored else {
|
|
panic!("expected compacted item");
|
|
};
|
|
assert_eq!(restored.guardian_history, Some(checkpoint));
|
|
let LegacyRolloutItem::Compacted(legacy) =
|
|
serde_json::from_value::<LegacyRolloutItem>(compacted_line)?
|
|
else {
|
|
panic!("expected legacy compacted item");
|
|
};
|
|
assert_eq!(legacy.replacement_history, vec![response_item]);
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn uploaded_audio_round_trips_in_canonical_message_content() -> Result<()> {
|
|
let mut message = response_message("user");
|
|
let ResponseItem::Message { content, .. } = &mut message else {
|
|
unreachable!()
|
|
};
|
|
content.push(ContentItem::InputAudio {
|
|
audio: AudioReference::Inline {
|
|
audio_url: "data:audio/wav;base64,aGVsbG8=".to_string(),
|
|
},
|
|
});
|
|
content.push(ContentItem::InputAudio {
|
|
audio: AudioReference::File {
|
|
file_id: "file_audio".to_string(),
|
|
},
|
|
});
|
|
content.push(ContentItem::InputText {
|
|
text: "after audio".to_string(),
|
|
});
|
|
let envelope = ResponseItemEnvelope::new(message);
|
|
let response = RolloutItem::ResponseItem(envelope.clone());
|
|
let compacted = RolloutItem::Compacted(Box::new(CompactedItem {
|
|
message: String::new(),
|
|
replacement_history: Some(vec![envelope.clone()]),
|
|
guardian_history: Some(GuardianHistoryCheckpoint(vec![envelope])),
|
|
retained_context: None,
|
|
mcp_resource_origins: None,
|
|
window_number: None,
|
|
first_window_id: None,
|
|
previous_window_id: None,
|
|
window_id: None,
|
|
compaction_response_id: None,
|
|
latest_token_usage_record: None,
|
|
resume_metadata: None,
|
|
}));
|
|
for (item, paths) in [
|
|
(response, vec!["/payload/content"]),
|
|
(
|
|
compacted,
|
|
vec![
|
|
"/payload/replacement_history/0/content",
|
|
"/payload/guardian_history/0/content",
|
|
],
|
|
),
|
|
] {
|
|
let mut serialized = serde_json::to_value(&item)?;
|
|
for path in paths {
|
|
assert_eq!(
|
|
serialized.pointer(path),
|
|
Some(&json!([
|
|
{"type": "input_text", "text": "hello"},
|
|
{"type": "input_audio", "audio_url": "data:audio/wav;base64,aGVsbG8="},
|
|
{"type": "input_audio", "file_id": "file_audio"},
|
|
{"type": "input_text", "text": "after audio"},
|
|
]))
|
|
);
|
|
// Rollouts from the prototype can contain this extra field. Reading
|
|
// them must preserve the same file reference in every history shape.
|
|
serialized.pointer_mut(path).unwrap()[2]["duration_ms"] = json!(1_000);
|
|
}
|
|
match (serde_json::from_value::<RolloutItem>(serialized)?, item) {
|
|
(RolloutItem::ResponseItem(restored), RolloutItem::ResponseItem(original)) => {
|
|
assert_eq!(restored, original)
|
|
}
|
|
(RolloutItem::Compacted(restored), RolloutItem::Compacted(original)) => {
|
|
assert_eq!(restored, original)
|
|
}
|
|
_ => panic!("unexpected rollout variant"),
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
/// Preserves the established tagged payload representation for every rollout variant.
|
|
fn rollout_item_variants_preserve_existing_payload_shapes() -> Result<()> {
|
|
let cwd = std::env::current_dir()?;
|
|
let foreign_file_system = FileSystemSandboxPolicy::restricted(vec![FileSystemSandboxEntry {
|
|
path: FileSystemPath::Path {
|
|
path: if cfg!(windows) {
|
|
"file:///workspace/foreign"
|
|
} else {
|
|
"file:///C:/workspace/foreign"
|
|
}
|
|
.parse()?,
|
|
},
|
|
access: FileSystemAccessMode::Write,
|
|
missing_path_behavior: None,
|
|
}]);
|
|
let denied_file_system = FileSystemSandboxPolicy::restricted(vec![FileSystemSandboxEntry {
|
|
path: FileSystemPath::GlobPattern {
|
|
pattern: "**/private/**".to_string(),
|
|
},
|
|
access: FileSystemAccessMode::Deny,
|
|
missing_path_behavior: None,
|
|
}]);
|
|
let fixtures = [
|
|
json!({
|
|
"type": "session_meta",
|
|
"payload": SessionMetaLine {
|
|
meta: SessionMeta::default(),
|
|
git: None,
|
|
},
|
|
}),
|
|
json!({
|
|
"type": "response_item",
|
|
"payload": response_message("user"),
|
|
}),
|
|
json!({
|
|
"type": "inter_agent_communication",
|
|
"payload": {
|
|
"author": "/root",
|
|
"recipient": "/root/child",
|
|
"other_recipients": [],
|
|
"content": "hello",
|
|
"trigger_turn": false,
|
|
},
|
|
}),
|
|
json!({
|
|
"type": "inter_agent_communication_metadata",
|
|
"payload": { "trigger_turn": true },
|
|
}),
|
|
json!({
|
|
"type": "compacted",
|
|
"payload": {
|
|
"message": "summary",
|
|
"compaction_response_id": null,
|
|
"latest_token_usage_record": null,
|
|
},
|
|
}),
|
|
json!({
|
|
"type": "turn_context",
|
|
"payload": {
|
|
"cwd": cwd,
|
|
"approval_policy": "never",
|
|
"sandbox_policy": { "type": "danger-full-access" },
|
|
"permission_profile": PermissionProfile::Disabled,
|
|
"model": "gpt-5",
|
|
"summary": "auto",
|
|
},
|
|
}),
|
|
json!({
|
|
"type": "turn_context",
|
|
"payload": {
|
|
"turn_id": "interrupted-turn",
|
|
"cwd": cwd,
|
|
"approval_policy": "never",
|
|
"sandbox_policy": {
|
|
"type": "workspace-write",
|
|
"network_access": false,
|
|
"exclude_tmpdir_env_var": true, "exclude_slash_tmp": true,
|
|
},
|
|
"permission_profile": PermissionProfile::from_runtime_permissions(
|
|
&foreign_file_system,
|
|
NetworkSandboxPolicy::Restricted,
|
|
),
|
|
"file_system_sandbox_policy": codex_protocol::permissions::RawFileSystemSandboxPolicy::try_from(foreign_file_system).expect("serializable foreign root"),
|
|
"model": "gpt-5",
|
|
"summary": "auto",
|
|
},
|
|
}),
|
|
json!({
|
|
"type": "turn_context",
|
|
"payload": {
|
|
"cwd": cwd, "approval_policy": "never", "model": "gpt-5",
|
|
"sandbox_policy": { "type": "read-only" },
|
|
"permission_profile": PermissionProfile::from_runtime_permissions(
|
|
&denied_file_system, NetworkSandboxPolicy::Restricted,
|
|
),
|
|
"file_system_sandbox_policy": codex_protocol::permissions::RawFileSystemSandboxPolicy::try_from(denied_file_system).expect("serializable deny rule"),
|
|
},
|
|
}),
|
|
json!({
|
|
"type": "token_usage_record",
|
|
"payload": {
|
|
"thread_id": "0195cda5-433d-7f9a-9d7b-a9f15b60c2e2",
|
|
"turn_id": "turn-1",
|
|
"session_id": "0195cda5-433d-7f9a-9d7b-a9f15b60c2e2",
|
|
"root_turn_id": "turn-1",
|
|
"response_id": "response-1",
|
|
"usage": {
|
|
"input_tokens": 10,
|
|
"cached_input_tokens": 2,
|
|
"cache_write_input_tokens": 0,
|
|
"output_tokens": 3,
|
|
"reasoning_output_tokens": 1,
|
|
"total_tokens": 13,
|
|
},
|
|
"turn_token_usage": {
|
|
"input_tokens": 10,
|
|
"cached_input_tokens": 2,
|
|
"cache_write_input_tokens": 0,
|
|
"output_tokens": 3,
|
|
"reasoning_output_tokens": 1,
|
|
"total_tokens": 13,
|
|
},
|
|
"thread_token_usage": {
|
|
"input_tokens": 10,
|
|
"cached_input_tokens": 2,
|
|
"cache_write_input_tokens": 0,
|
|
"output_tokens": 3,
|
|
"reasoning_output_tokens": 1,
|
|
"total_tokens": 13,
|
|
},
|
|
},
|
|
}),
|
|
json!({
|
|
"type": "world_state",
|
|
"payload": { "full": true, "state": { "cwd": "/tmp" } },
|
|
}),
|
|
json!({
|
|
"type": "security_risk_score",
|
|
"payload": {
|
|
"scores": {
|
|
"action_risk": 0.92,
|
|
"data_exfiltration": 0.31,
|
|
},
|
|
},
|
|
}),
|
|
json!({
|
|
"type": "event_msg",
|
|
"payload": { "type": "warning", "message": "heads up" },
|
|
}),
|
|
json!({
|
|
"type": "retained_context",
|
|
"payload": {
|
|
"type": "verified_answer",
|
|
"turn_id": "turn-1",
|
|
"call_id": "ask-1",
|
|
"questions": [{"question": "Publish?", "answer": "Only privately."}],
|
|
},
|
|
}),
|
|
json!({
|
|
"type": "realtime_item",
|
|
"payload": {
|
|
"id": "segment-1",
|
|
"realtime_session_id": "session-1",
|
|
"type": "transcript_segment",
|
|
"role": "assistant",
|
|
"text": "hello",
|
|
},
|
|
}),
|
|
];
|
|
|
|
for expected in fixtures {
|
|
let item = serde_json::from_value::<RolloutItem>(expected.clone())?;
|
|
assert_eq!(serde_json::to_value(item)?, expected);
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
/// Keeps the generated schema aligned with each variant's actual persisted shape.
|
|
fn rollout_item_schema_matches_tagged_payload_and_sibling_metadata() -> Result<()> {
|
|
let schema = serde_json::to_value(schemars::schema_for!(RolloutItem))?;
|
|
let variants = schema["oneOf"].as_array().expect("rollout variants");
|
|
assert_eq!(variants.len(), 13);
|
|
|
|
for variant in variants {
|
|
let required = variant["required"].as_array().expect("required fields");
|
|
assert!(required.contains(&json!("type")), "schema: {variant}");
|
|
assert!(required.contains(&json!("payload")), "schema: {variant}");
|
|
}
|
|
|
|
let response_item = variants
|
|
.iter()
|
|
.find(|variant| variant["properties"]["type"]["enum"] == json!(["response_item"]))
|
|
.expect("response item schema");
|
|
assert!(response_item["properties"].get("metadata").is_some());
|
|
let payload_ref = response_item["properties"]["payload"]["$ref"]
|
|
.as_str()
|
|
.expect("response item payload reference");
|
|
let payload = schema
|
|
.pointer(
|
|
payload_ref
|
|
.strip_prefix('#')
|
|
.expect("local schema reference"),
|
|
)
|
|
.expect("response item payload");
|
|
assert!(payload["properties"].get("id_allocation").is_some());
|
|
|
|
let compacted = &schema["definitions"]["CompactedItem"];
|
|
assert_eq!(
|
|
compacted["properties"]["replacement_history"]["items"]["$ref"],
|
|
payload_ref
|
|
);
|
|
assert_eq!(
|
|
compacted["properties"]["replacement_history_metadata"]["items"]["$ref"],
|
|
json!("#/definitions/CodexHarnessMetadata")
|
|
);
|
|
let required = compacted["required"].as_array().expect("required fields");
|
|
assert!(!required.contains(&json!("replacement_history")));
|
|
assert!(!required.contains(&json!("replacement_history_metadata")));
|
|
Ok(())
|
|
}
|
|
|
|
fn response_message(role: &str) -> ResponseItem {
|
|
ResponseItem::Message {
|
|
status: None,
|
|
encrypted_content: None,
|
|
id: None,
|
|
role: role.to_string(),
|
|
content: vec![ContentItem::InputText {
|
|
text: "hello".to_string(),
|
|
}],
|
|
phase: None,
|
|
internal_chat_message_metadata_passthrough: None,
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
/// Preserves the stored compacted-item window metadata shape.
|
|
fn compacted_item_serializes_window_number_and_id() -> Result<()> {
|
|
let item = CompactedItem {
|
|
message: "summary".to_string(),
|
|
replacement_history: None,
|
|
retained_context: None,
|
|
guardian_history: None,
|
|
mcp_resource_origins: None,
|
|
window_number: Some(3),
|
|
first_window_id: ContextWindowId::parse("019b3f6e-0000-7000-8000-000000000001"),
|
|
previous_window_id: ContextWindowId::parse("019b3f6e-0000-7000-8000-000000000002"),
|
|
window_id: ContextWindowId::parse("019b3f6e-7a10-7cc3-8b6e-1d09e2f7a001"),
|
|
compaction_response_id: None,
|
|
latest_token_usage_record: None,
|
|
resume_metadata: None,
|
|
};
|
|
|
|
assert_eq!(
|
|
serde_json::to_value(item)?,
|
|
json!({
|
|
"message": "summary",
|
|
"window_number": 3,
|
|
"first_window_id": "019b3f6e-0000-7000-8000-000000000001",
|
|
"previous_window_id": "019b3f6e-0000-7000-8000-000000000002",
|
|
"window_id": "019b3f6e-7a10-7cc3-8b6e-1d09e2f7a001",
|
|
"compaction_response_id": null,
|
|
"latest_token_usage_record": null,
|
|
})
|
|
);
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn model_id_ordinals_resume_at_the_checkpoint_and_advance_for_local_items() -> Result<()> {
|
|
let record = |ordinal| {
|
|
json!({
|
|
"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [],
|
|
"id": "external", "id_allocation": {"salt": "item", "ordinal": ordinal, "value": 3}}
|
|
})
|
|
};
|
|
let source = |ordinal| {
|
|
json!({
|
|
"id": {"turn_id": "turn", "message_id": "external", "role": "assistant"},
|
|
"revision": {"id": "retained_item007",
|
|
"id_allocation": {"prefix": "retained", "salt": "item", "ordinal": ordinal, "value": 7}},
|
|
"complete": true
|
|
})
|
|
};
|
|
let mut tail = record(24);
|
|
tail["metadata"] = json!({
|
|
"retained_source": source(25),
|
|
"guardian_sources": [source(300)],
|
|
"guardian_review_ids": [{"id": "review_item008",
|
|
"id_allocation": {"prefix": "review", "salt": "item", "ordinal": 301, "value": 8}}]
|
|
});
|
|
let mut records: Vec<RolloutItem> = serde_json::from_value(json!([
|
|
record(19),
|
|
{"type": "compacted", "payload": {
|
|
"message": "", "window_number": 4,
|
|
"window_id": {"salt": "window", "ordinal": 4, "value": 812},
|
|
"replacement_history": [record(8)["payload"]],
|
|
"resume_metadata": {"next_item_ordinal": 24}
|
|
}},
|
|
tail
|
|
]))?;
|
|
assert_eq!(crate::next_model_id_ordinals(&[]), (0, 0));
|
|
assert_eq!(crate::next_model_id_ordinals(&records[1..2]), (24, 5));
|
|
assert_eq!(crate::next_model_id_ordinals(&records[1..]), (26, 5));
|
|
assert_eq!(crate::next_model_id_ordinals(&records), (26, 5));
|
|
// An append containing a checkpoint and a later allocation stamps only the prefix.
|
|
assert_eq!(crate::stamp_item_ordinals(/*next*/ 25, &mut records), 26);
|
|
assert_eq!(crate::next_model_id_ordinals(&records[1..2]), (25, 5));
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn structured_window_ids_round_trip_in_session_metadata_and_compaction() -> Result<()> {
|
|
let uuid = "019020ef-10ff-7000-8000-000000000001";
|
|
let meta: codex_protocol::protocol::SessionContextWindow =
|
|
serde_json::from_value(json!({"window_id": uuid}))?;
|
|
let id = meta.window_id.validated().expect("UUIDv7 window");
|
|
assert_eq!((id.to_string(), id.allocation()), (uuid.to_owned(), None));
|
|
let first = json!({"salt":"window","ordinal":0,"value":42});
|
|
let previous = json!({"salt":"window","ordinal":1,"value":456});
|
|
let current = json!({"salt":"window","ordinal":2,"value":7});
|
|
let header = json!({"window_id": first});
|
|
let meta: codex_protocol::protocol::SessionContextWindow =
|
|
serde_json::from_value(header.clone())?;
|
|
assert_eq!(meta.window_id.to_string(), "window042");
|
|
assert_eq!(serde_json::to_value(meta)?, header);
|
|
let item: CompactedItem = serde_json::from_value(json!({
|
|
"message":"summary", "window_number":2, "first_window_id":first,
|
|
"previous_window_id":previous, "window_id":current,
|
|
}))?;
|
|
let id = item.window_id.as_ref().unwrap().validated().unwrap();
|
|
assert_eq!(
|
|
(id.to_string(), id.allocation().unwrap().ordinal()),
|
|
("window007".to_string(), 2)
|
|
);
|
|
let wire = serde_json::to_value(item)?;
|
|
assert_eq!(
|
|
(
|
|
&wire["first_window_id"],
|
|
&wire["previous_window_id"],
|
|
&wire["window_id"]
|
|
),
|
|
(&first, &previous, ¤t)
|
|
);
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
/// Keeps legacy numeric window IDs readable in stored compacted items.
|
|
fn compacted_item_migrates_legacy_numeric_window_id() -> Result<()> {
|
|
let item = serde_json::from_value::<CompactedItem>(json!({
|
|
"message": "summary",
|
|
"window_id": 3,
|
|
}))?;
|
|
|
|
assert_eq!(
|
|
item,
|
|
CompactedItem {
|
|
message: "summary".to_string(),
|
|
replacement_history: None,
|
|
retained_context: None,
|
|
guardian_history: None,
|
|
mcp_resource_origins: None,
|
|
window_number: Some(3),
|
|
first_window_id: None,
|
|
previous_window_id: None,
|
|
window_id: None,
|
|
compaction_response_id: None,
|
|
latest_token_usage_record: None,
|
|
resume_metadata: None,
|
|
}
|
|
);
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn copied_history_uses_persisted_history_mode() -> Result<()> {
|
|
let thread_id = ThreadId::from_string("00000000-0000-0000-0000-000000000001")?;
|
|
let session_meta = RolloutItem::SessionMeta(Box::new(SessionMetaLine {
|
|
meta: SessionMeta {
|
|
session_id: thread_id.into(),
|
|
id: thread_id,
|
|
history_mode: ThreadHistoryMode::Legacy,
|
|
..SessionMeta::default()
|
|
},
|
|
git: None,
|
|
}));
|
|
let history = InitialHistory::Resumed(ResumedHistory {
|
|
history_revision: None,
|
|
conversation_id: thread_id,
|
|
history: Arc::new(vec![session_meta.clone()]),
|
|
rollout_path: None,
|
|
});
|
|
|
|
assert_eq!(
|
|
history.get_history_mode(ThreadHistoryMode::Paginated),
|
|
ThreadHistoryMode::Legacy
|
|
);
|
|
assert_eq!(
|
|
InitialHistory::Forked(vec![session_meta]).get_history_mode(ThreadHistoryMode::Paginated),
|
|
ThreadHistoryMode::Legacy
|
|
);
|
|
assert_eq!(
|
|
InitialHistory::New.get_history_mode(ThreadHistoryMode::Paginated),
|
|
ThreadHistoryMode::Paginated
|
|
);
|
|
assert_eq!(
|
|
InitialHistory::Resumed(ResumedHistory {
|
|
history_revision: None,
|
|
conversation_id: thread_id,
|
|
history: Arc::new(Vec::new()),
|
|
rollout_path: None,
|
|
})
|
|
.get_history_mode(ThreadHistoryMode::Paginated),
|
|
ThreadHistoryMode::Paginated
|
|
);
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn multi_agent_version_uses_newest_present_session_meta_value() -> Result<()> {
|
|
let thread_id = ThreadId::from_string("67e55044-10b1-426f-9247-bb680e5fe0c8")?;
|
|
let older_meta = SessionMetaLine {
|
|
meta: SessionMeta {
|
|
session_id: thread_id.into(),
|
|
id: thread_id,
|
|
multi_agent_version: Some(MultiAgentVersion::V2),
|
|
..Default::default()
|
|
},
|
|
git: None,
|
|
};
|
|
let newer_meta_without_version = SessionMetaLine {
|
|
meta: SessionMeta {
|
|
session_id: thread_id.into(),
|
|
id: thread_id,
|
|
multi_agent_version: None,
|
|
..Default::default()
|
|
},
|
|
git: None,
|
|
};
|
|
|
|
assert_eq!(
|
|
multi_agent_version_from_items(
|
|
&[
|
|
RolloutItem::SessionMeta(Box::new(older_meta)),
|
|
RolloutItem::SessionMeta(Box::new(newer_meta_without_version)),
|
|
],
|
|
Some(thread_id),
|
|
),
|
|
Some(MultiAgentVersion::V2)
|
|
);
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn multi_agent_version_uses_compaction_metadata_without_turn_context() -> Result<()> {
|
|
let compacted = serde_json::from_value::<CompactedItem>(json!({
|
|
"message": "summary",
|
|
"replacement_history": [],
|
|
"window_number": 1,
|
|
"resume_metadata": {"multi_agent_version": "v2"}
|
|
}))?;
|
|
|
|
assert_eq!(
|
|
InitialHistory::Forked(vec![RolloutItem::Compacted(Box::new(compacted))])
|
|
.get_multi_agent_version(),
|
|
Some(MultiAgentVersion::V2)
|
|
);
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn dynamic_tools_updates_survive_replay_and_explicit_clear() -> Result<()> {
|
|
let tool = codex_protocol::dynamic_tools::DynamicToolSpec::Function(
|
|
codex_protocol::dynamic_tools::DynamicToolFunctionSpec {
|
|
name: "check_release".into(),
|
|
description: "Check the release.".into(),
|
|
input_schema: json!({"type": "object", "properties": {}}),
|
|
defer_loading: false,
|
|
},
|
|
);
|
|
let thread_id = ThreadId::new();
|
|
let mut items = vec![RolloutItem::SessionMeta(Box::new(SessionMetaLine {
|
|
meta: SessionMeta {
|
|
id: thread_id,
|
|
dynamic_tools: Some(vec![tool.clone()]),
|
|
..SessionMeta::default()
|
|
},
|
|
git: None,
|
|
}))];
|
|
let mut replacement = tool.clone();
|
|
if let codex_protocol::dynamic_tools::DynamicToolSpec::Function(tool) = &mut replacement {
|
|
tool.name = "check_deployment".into();
|
|
}
|
|
let checkpoint = |thread_id: ThreadId, tools: Vec<DynamicToolSpec>| -> Result<RolloutItem> {
|
|
Ok(RolloutItem::Compacted(Box::new(serde_json::from_value(
|
|
json!({
|
|
"message": "summary",
|
|
"replacement_history": [],
|
|
"window_number": 1,
|
|
"resume_metadata": {
|
|
"dynamic_tools": {"thread_id": thread_id, "tools": tools}
|
|
}
|
|
}),
|
|
)?)))
|
|
};
|
|
items.push(checkpoint(ThreadId::new(), vec![replacement.clone()])?);
|
|
assert_eq!(
|
|
latest_dynamic_tools(&items),
|
|
Some(std::slice::from_ref(&tool))
|
|
);
|
|
for expected in [vec![replacement], Vec::new()] {
|
|
for item in [
|
|
checkpoint(thread_id, expected.clone())?,
|
|
RolloutItem::DynamicToolsUpdated {
|
|
thread_id,
|
|
tools: expected.clone(),
|
|
},
|
|
] {
|
|
items.push(checkpoint(thread_id, vec![tool.clone()])?);
|
|
items.push(item);
|
|
// Metadata-only writes and inherited records cannot resurrect a replaced catalog.
|
|
items.push(items[0].clone());
|
|
items.push(RolloutItem::DynamicToolsUpdated {
|
|
thread_id: ThreadId::new(),
|
|
tools: vec![tool.clone()],
|
|
});
|
|
items.push(checkpoint(ThreadId::new(), vec![tool.clone()])?);
|
|
let serialized = serde_json::to_vec(&items)?;
|
|
let replayed: Vec<RolloutItem> = serde_json::from_slice(&serialized)?;
|
|
assert_eq!(
|
|
InitialHistory::Forked(replayed.clone()).get_dynamic_tools(),
|
|
Some(expected.clone())
|
|
);
|
|
assert_eq!(
|
|
InitialHistory::Resumed(ResumedHistory {
|
|
history_revision: None,
|
|
conversation_id: thread_id,
|
|
history: Arc::new(replayed),
|
|
rollout_path: None,
|
|
})
|
|
.get_dynamic_tools(),
|
|
Some(expected.clone())
|
|
);
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|