Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Always use streamed remote compaction for supported providers (#44255)

rka-oai3dc1e2a58406
diff --git a/codex-rs/analytics/src/analytics_client_tests.rs b/codex-rs/analytics/src/analytics_client_tests.rs
index fb570694c7..58ccd29382 100644
--- a/codex-rs/analytics/src/analytics_client_tests.rs
+++ b/codex-rs/analytics/src/analytics_client_tests.rs
@@ -1497,7 +1497,7 @@ fn compaction_event_serializes_expected_shape() {
turn_id: "turn-1".to_string(),
trigger: CompactionTrigger::Auto,
reason: CompactionReason::ContextLimit,
- implementation: CompactionImplementation::ResponsesCompact,
+ implementation: CompactionImplementation::ResponsesCompactionV2,
phase: CompactionPhase::MidTurn,
strategy: CompactionStrategy::Memento,
status: CompactionStatus::Completed,
@@ -1550,7 +1550,7 @@ fn compaction_event_serializes_expected_shape() {
"parent_thread_id": null,
"trigger": "auto",
"reason": "context_limit",
- "implementation": "responses_compact",
+ "implementation": "responses_compaction_v2",
"phase": "mid_turn",
"strategy": "memento",
"status": "completed",
diff --git a/codex-rs/app-server/tests/suite/v2/compaction.rs b/codex-rs/app-server/tests/suite/v2/compaction.rs
index 8264bd68c6..9f3d1a0e61 100644
--- a/codex-rs/app-server/tests/suite/v2/compaction.rs
+++ b/codex-rs/app-server/tests/suite/v2/compaction.rs
@@ -1,7 +1,7 @@
//! End-to-end compaction flow tests.
//!
//! Phases:
-//! 1) Arrange: mock responses/compact endpoints + config.
+//! 1) Arrange: mock Responses endpoints + config.
//! 2) Act: start a thread and submit multiple turns to trigger auto-compaction.
//! 3) Assert: verify item/started + item/completed notifications for context compaction.
@@ -30,14 +30,12 @@ use codex_app_server_protocol::TurnStartParams;
use codex_app_server_protocol::TurnStartResponse;
use codex_app_server_protocol::UserInput as V2UserInput;
use codex_config::types::AuthCredentialsStoreMode;
-use codex_features::Feature;
-use codex_protocol::models::ContentItem;
-use codex_protocol::models::ResponseItem;
use codex_utils_absolute_path::test_support::PathExt;
use core_test_support::responses;
use core_test_support::skip_if_no_network;
use pretty_assertions::assert_eq;
use tempfile::TempDir;
+use test_case::test_case;
use tokio::time::timeout;
// macOS and Windows Bazel CI can spend tens of seconds starting app-server
@@ -50,8 +48,16 @@ const AUTO_COMPACT_LIMIT: i64 = 1_000;
const COMPACT_PROMPT: &str = "Summarize the conversation.";
const INVALID_REQUEST_ERROR_CODE: i64 = -32600;
+#[derive(Clone, Copy)]
+enum CompactionRoute {
+ Local,
+ Remote,
+}
+
+#[test_case(CompactionRoute::Local; "local")]
+#[test_case(CompactionRoute::Remote; "streamed remote")]
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn auto_compaction_local_emits_started_and_completed_items() -> Result<()> {
+async fn auto_compaction_emits_started_and_completed_items(route: CompactionRoute) -> Result<()> {
skip_if_no_network!(Ok(()));
let server = responses::start_mock_server().await;
@@ -63,99 +69,39 @@ async fn auto_compaction_local_emits_started_and_completed_items() -> Result<()>
responses::ev_assistant_message("m2", "SECOND_REPLY"),
responses::ev_completed_with_tokens("r2", /*total_tokens*/ 330_000),
]);
+ let summary = match route {
+ CompactionRoute::Local => responses::ev_assistant_message("m3", "LOCAL_SUMMARY"),
+ CompactionRoute::Remote => serde_json::json!({
+ "type": "response.output_item.done",
+ "item": {
+ "type": "compaction",
+ "encrypted_content": "ENCRYPTED_COMPACTION_SUMMARY",
+ },
+ }),
+ };
let sse3 = responses::sse(vec![
- responses::ev_assistant_message("m3", "LOCAL_SUMMARY"),
+ summary,
responses::ev_completed_with_tokens("r3", /*total_tokens*/ 200),
]);
let sse4 = responses::sse(vec![
responses::ev_assistant_message("m4", "FINAL_REPLY"),
responses::ev_completed_with_tokens("r4", /*total_tokens*/ 120),
]);
- responses::mount_sse_sequence(&server, vec![sse1, sse2, sse3, sse4]).await;
+ let requests = responses::mount_sse_sequence(&server, vec![sse1, sse2, sse3, sse4]).await;
let codex_home = TempDir::new()?;
- compaction_config(&server.uri(), AUTO_COMPACT_LIMIT).write(codex_home.path())?;
-
- let mut mcp = TestAppServer::builder()
- .with_codex_home(codex_home.path())
- .build_initialized_with_timeout(DEFAULT_READ_TIMEOUT)
- .await?;
-
- let thread_id = start_thread(&mut mcp).await?;
- for message in ["first", "second", "third"] {
- send_turn_and_wait(&mut mcp, &thread_id, message).await?;
+ let mut config = compaction_config(&server.uri(), /*auto_compact_limit*/ 200_000);
+ if let CompactionRoute::Remote = route {
+ config = config
+ .with_provider_name("OpenAI")
+ .with_provider_config("requires_openai_auth = true");
+ write_chatgpt_auth(
+ codex_home.path(),
+ ChatGptAuthFixture::new("access-chatgpt").plan_type("pro"),
+ AuthCredentialsStoreMode::File,
+ )?;
}
-
- let started = wait_for_context_compaction_started(&mut mcp).await?;
- let completed = wait_for_context_compaction_completed(&mut mcp).await?;
-
- let ThreadItem::ContextCompaction { id: started_id } = started.item else {
- unreachable!("started item should be context compaction");
- };
- let ThreadItem::ContextCompaction { id: completed_id } = completed.item else {
- unreachable!("completed item should be context compaction");
- };
-
- assert_eq!(started.thread_id, thread_id);
- assert_eq!(completed.thread_id, thread_id);
- assert_eq!(started_id, completed_id);
-
- Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn auto_compaction_remote_emits_started_and_completed_items() -> Result<()> {
- skip_if_no_network!(Ok(()));
- const REMOTE_AUTO_COMPACT_LIMIT: i64 = 200_000;
-
- let server = responses::start_mock_server().await;
- let sse1 = responses::sse(vec![
- responses::ev_assistant_message("m1", "FIRST_REPLY"),
- responses::ev_completed_with_tokens("r1", /*total_tokens*/ 70_000),
- ]);
- let sse2 = responses::sse(vec![
- responses::ev_assistant_message("m2", "SECOND_REPLY"),
- responses::ev_completed_with_tokens("r2", /*total_tokens*/ 330_000),
- ]);
- let sse3 = responses::sse(vec![
- responses::ev_assistant_message("m3", "FINAL_REPLY"),
- responses::ev_completed_with_tokens("r3", /*total_tokens*/ 120),
- ]);
- let responses_log = responses::mount_sse_sequence(&server, vec![sse1, sse2, sse3]).await;
-
- let compacted_history = vec![
- ResponseItem::Message {
- id: None,
- role: "assistant".to_string(),
- content: vec![ContentItem::OutputText {
- text: "REMOTE_COMPACT_SUMMARY".to_string(),
- }],
- phase: None,
- internal_chat_message_metadata_passthrough: None,
- },
- ResponseItem::Compaction {
- id: None,
- encrypted_content: "ENCRYPTED_COMPACTION_SUMMARY".to_string(),
- internal_chat_message_metadata_passthrough: None,
- },
- ];
- let compact_mock = responses::mount_compact_json_once(
- &server,
- serde_json::json!({ "output": compacted_history }),
- )
- .await;
-
- let codex_home = TempDir::new()?;
- compaction_config(&server.uri(), REMOTE_AUTO_COMPACT_LIMIT)
- .disable_feature(Feature::RemoteCompactionV2)
- .with_provider_name("OpenAI")
- .with_provider_config("requires_openai_auth = true")
- .write(codex_home.path())?;
- write_chatgpt_auth(
- codex_home.path(),
- ChatGptAuthFixture::new("access-chatgpt").plan_type("pro"),
- AuthCredentialsStoreMode::File,
- )?;
+ config.write(codex_home.path())?;
let mut mcp = TestAppServer::builder()
.with_codex_home(codex_home.path())
@@ -182,65 +128,31 @@ async fn auto_compaction_remote_emits_started_and_completed_items() -> Result<()
assert_eq!(completed.thread_id, thread_id);
assert_eq!(started_id, completed_id);
- let compact_requests = compact_mock.requests();
- assert_eq!(compact_requests.len(), 1);
- assert_eq!(compact_requests[0].path(), "/v1/responses/compact");
-
- let response_requests = responses_log.requests();
- assert_eq!(response_requests.len(), 3);
- let turn_metadata = response_requests
- .iter()
- .map(|request| {
- request
- .header("x-codex-turn-metadata")
- .as_deref()
- .map(parse_json_header)
- .expect("turn request should include turn metadata")
- })
- .collect::<Vec<_>>();
- for (request, metadata) in response_requests.iter().zip(&turn_metadata) {
- assert_eq!(metadata["request_kind"].as_str(), Some("turn"));
- assert!(
- metadata["turn_id"]
- .as_str()
- .is_some_and(|turn_id| !turn_id.is_empty()),
- "turn request should carry a non-empty turn id"
- );
- assert_eq!(
- metadata["window_id"].as_str(),
- request.header("x-codex-window-id").as_deref()
- );
- assert!(metadata.get("compaction").is_none());
+ let requests = requests.requests();
+ assert_eq!(requests.len(), 4);
+ let compact_request = &requests[2];
+ assert_eq!(compact_request.path(), "/v1/responses");
+ match route {
+ CompactionRoute::Local => {
+ assert!(
+ compact_request
+ .inputs_of_type("compaction_trigger")
+ .is_empty()
+ );
+ assert!(compact_request.body_contains_text(COMPACT_PROMPT));
+ }
+ CompactionRoute::Remote => {
+ assert_eq!(
+ compact_request.inputs_of_type("compaction_trigger").len(),
+ 1
+ );
+ assert_eq!(
+ requests[3].inputs_of_type("compaction")[0]["encrypted_content"],
+ "ENCRYPTED_COMPACTION_SUMMARY"
+ );
+ }
}
- let compact_metadata = compact_requests[0]
- .header("x-codex-turn-metadata")
- .as_deref()
- .map(parse_json_header)
- .expect("compact request should include turn metadata");
- assert_eq!(
- compact_metadata["request_kind"].as_str(),
- Some("compaction")
- );
- assert_eq!(
- compact_metadata["compaction"],
- serde_json::json!({
- "trigger": "auto",
- "reason": "context_limit",
- "implementation": "responses_compact",
- "phase": "pre_turn",
- "strategy": "memento",
- })
- );
- assert_eq!(
- compact_metadata["turn_id"], turn_metadata[2]["turn_id"],
- "pre-turn compaction should carry the current turn id"
- );
- assert_eq!(
- compact_metadata["window_id"].as_str(),
- compact_requests[0].header("x-codex-window-id").as_deref()
- );
-
Ok(())
}
@@ -522,10 +434,6 @@ async fn wait_for_context_compaction_completed(
}
}
-fn parse_json_header(value: &str) -> serde_json::Value {
- serde_json::from_str(value).expect("turn metadata should be JSON")
-}
-
fn compaction_config(server_uri: &str, auto_compact_limit: i64) -> MockResponsesConfig {
MockResponsesConfig::new(server_uri)
.with_root_config(&format!(
diff --git a/codex-rs/app-server/tests/suite/v2/guardian_v2.rs b/codex-rs/app-server/tests/suite/v2/guardian_v2.rs
index 0bfbe618df..ab5b6ecd31 100644
--- a/codex-rs/app-server/tests/suite/v2/guardian_v2.rs
+++ b/codex-rs/app-server/tests/suite/v2/guardian_v2.rs
@@ -385,7 +385,26 @@ async fn parent_response(
State(state): State<Arc<MockResponsesState>>,
Json(request): Json<Value>,
) -> impl IntoResponse {
- let events = if request["model"] == "gpt-5.6-luna" {
+ let events = if request["input"].as_array().is_some_and(|input| {
+ input
+ .last()
+ .is_some_and(|item| item["type"] == "compaction_trigger")
+ }) {
+ assert!(state.compact_root_after_answer);
+ assert!(request.to_string().contains("guardian-user-input"));
+ vec![
+ responses::ev_response_created("root-compaction"),
+ json!({
+ "type": "response.output_item.done",
+ "item": {
+ "type": "compaction",
+ "id": "cmp_root",
+ "encrypted_content": "opaque root summary",
+ },
+ }),
+ responses::ev_completed("root-compaction"),
+ ]
+ } else if request["model"] == "gpt-5.6-luna" {
luna_response(&state, request).await
} else if request
.pointer("/client_metadata/x-openai-subagent")
@@ -712,30 +731,53 @@ async fn guardian_v2_routes_scoped_tool_approvals(
let responses_url = format!("http://{}", listener.local_addr()?);
let router = Router::new()
.route("/v1/responses", get(luna_websocket).post(parent_response))
- .route("/v1/responses/compact", post(|Json(request): Json<Value>| async move {
- assert!(request.to_string().contains("guardian-user-input"));
- Json(json!({"output": [{"type": "compaction", "id": "cmp_root", "encrypted_content": "opaque root summary"}]}))
- }))
.route(
"/metrics",
post(
|State(state): State<Arc<MockResponsesState>>, body: String| async move {
if matches!(state.transcript_content, TranscriptContent::MixedEvidence) {
let payload: Value = serde_json::from_str(&body).expect("OTLP JSON");
- for metric in payload["resourceMetrics"].as_array().into_iter().flatten()
- .flat_map(|resource| resource["scopeMetrics"].as_array().into_iter().flatten())
+ for metric in payload["resourceMetrics"]
+ .as_array()
+ .into_iter()
+ .flatten()
+ .flat_map(|resource| {
+ resource["scopeMetrics"].as_array().into_iter().flatten()
+ })
.flat_map(|scope| scope["metrics"].as_array().into_iter().flatten())
- .filter(|metric| matches!(metric["name"].as_str(), Some("codex.guardian.context.request_tokens" | "codex.guardian.context.section_cost")))
+ .filter(|metric| {
+ matches!(
+ metric["name"].as_str(),
+ Some(
+ "codex.guardian.context.request_tokens"
+ | "codex.guardian.context.section_cost"
+ )
+ )
+ })
{
let name = metric["name"].as_str().expect("context metric name");
- for point in metric["histogram"]["dataPoints"].as_array().into_iter().flatten() {
- let attributes = point["attributes"].as_array().expect("metric attributes");
+ for point in metric["histogram"]["dataPoints"]
+ .as_array()
+ .into_iter()
+ .flatten()
+ {
+ let attributes =
+ point["attributes"].as_array().expect("metric attributes");
for target in ["sync", "async"] {
- if attributes.iter().any(|attr| attr["key"] == "target" && attr["value"]["stringValue"] == target) {
- let mut bounds = state.context_metric_bounds.lock().expect("context metric bounds");
+ if attributes.iter().any(|attr| {
+ attr["key"] == "target"
+ && attr["value"]["stringValue"] == target
+ }) {
+ let mut bounds = state
+ .context_metric_bounds
+ .lock()
+ .expect("context metric bounds");
bounds.insert(
(name.to_owned(), target.to_owned()),
- point["explicitBounds"].as_array().and_then(|bounds| bounds.last()).and_then(Value::as_f64),
+ point["explicitBounds"]
+ .as_array()
+ .and_then(|bounds| bounds.last())
+ .and_then(Value::as_f64),
);
if bounds.len() == 4 {
state.context_metrics_recorded.notify_one();
@@ -852,7 +894,6 @@ async fn guardian_v2_routes_scoped_tool_approvals(
if matches!(lifecycle, ThreadLifecycle::RootUserInputCompaction) {
mock_config = mock_config
.with_provider_name("OpenAI")
- .disable_feature(Feature::RemoteCompactionV2)
.disable_feature(Feature::TokenBudget)
.disable_feature(Feature::EnableRequestCompression);
}
diff --git a/codex-rs/app-server/tests/suite/v2/guardian_v2_history_tests.rs b/codex-rs/app-server/tests/suite/v2/guardian_v2_history_tests.rs
index e5b5908ff3..66be28dd7e 100644
--- a/codex-rs/app-server/tests/suite/v2/guardian_v2_history_tests.rs
+++ b/codex-rs/app-server/tests/suite/v2/guardian_v2_history_tests.rs
@@ -14,7 +14,6 @@ use axum::Router;
use axum::extract::State;
use axum::http::header;
use axum::routing::get;
-use axum::routing::post;
use codex_app_server_protocol::ApprovalsReviewer;
use codex_app_server_protocol::AskForApproval;
use codex_app_server_protocol::GuardianApprovalReview;
@@ -184,12 +183,33 @@ async fn guardians_retain_evidence_after_compaction_and_discard_it_after_rollbac
get(luna_websocket).post({
let parent_requests = Arc::clone(&parent_requests);
let review_requests = Arc::clone(&review_requests);
+ let compact_requests = Arc::clone(&compact_requests);
+ let checkpoint = checkpoint.clone();
move |State(classifier): State<Arc<MockResponsesState>>,
Json(request): Json<Value>| {
let parent_requests = Arc::clone(&parent_requests);
let review_requests = Arc::clone(&review_requests);
+ let compact_requests = Arc::clone(&compact_requests);
+ let checkpoint = checkpoint.clone();
async move {
- let events = if request["model"] == "gpt-5.6-luna" {
+ let events = if request["input"].as_array().is_some_and(|input| {
+ input
+ .iter()
+ .any(|item| item["type"] == "compaction_trigger")
+ }) {
+ compact_requests
+ .lock()
+ .expect("request log lock")
+ .push(request);
+ vec![
+ responses::ev_assistant_message("summary", SUMMARY),
+ json!({
+ "type": "response.output_item.done",
+ "item": checkpoint,
+ }),
+ responses::ev_completed("compact"),
+ ]
+ } else if request["model"] == "gpt-5.6-luna" {
luna_response(&classifier, request).await
} else if request["client_metadata"]["x-openai-subagent"] == "guardian" {
review_requests
@@ -243,29 +263,6 @@ async fn guardians_retain_evidence_after_compaction_and_discard_it_after_rollbac
}
}),
)
- .route(
- "/v1/responses/compact",
- post({
- let compact_requests = Arc::clone(&compact_requests);
- let checkpoint = checkpoint.clone();
- move |Json(request): Json<Value>| {
- let compact_requests = Arc::clone(&compact_requests);
- let checkpoint = checkpoint.clone();
- async move {
- compact_requests
- .lock()
- .expect("request log lock")
- .push(request);
- Json(json!({"output": [
- {"type": "message", "role": "assistant", "content": [
- {"type": "output_text", "text": SUMMARY}
- ]},
- checkpoint
- ]}))
- }
- }
- }),
- )
.with_state(Arc::clone(&classifier));
let listener = TcpListener::bind("127.0.0.1:0").await?;
let responses_url = format!("http://{}", listener.local_addr()?);
@@ -288,7 +285,7 @@ async fn guardians_retain_evidence_after_compaction_and_discard_it_after_rollbac
.enable_feature(Feature::GuardianApproval)
.enable_feature(Feature::GuardianReuseParentCompaction)
.disable_feature(Feature::EnableRequestCompression)
- .disable_feature(Feature::RemoteCompactionV2)
+ .enable_feature(Feature::RemoteCompactionV2)
.disable_feature(Feature::TokenBudget)
.with_extra_config(&format!(
"[mcp_servers.{TEST_SERVER_NAME}]\nurl = \"{mcp_url}/mcp\"\ndefault_tools_approval_mode = \"prompt\"\n\n[features.guardianv2]\nenabled = true\nthread_context = {thread_context_enabled}\npersist_scores = true\nreuse_parent_compaction = {reuse_parent_compaction}\n\n[features.guardianv2.review_scope]\ncomputer_use_only = false"
@@ -616,9 +613,16 @@ async fn guardians_retain_evidence_after_compaction_and_discard_it_after_rollbac
let output = output["output"].as_str().expect("tool output text");
assert!(output.contains(&expected_output), "{output}");
} else {
- let parent_input = serde_json::to_string(&parent[index * 2 + 1]["input"])?;
- assert!(!parent_input.contains(RESTRICTION));
+ let parent_items = parent[index * 2 + 1]["input"]
+ .as_array()
+ .expect("request input array");
+ let parent_input = serde_json::to_string(parent_items)?;
+ // V2 keeps bounded user history while replacing old tool output with a checkpoint.
+ assert_eq!(parent_input.contains(RESTRICTION), index <= 3);
assert!(!parent_input.contains(EVIDENCE));
+ assert!(!parent_items.iter().any(|item| {
+ item["type"] == "function_call_output" && item["call_id"] == "inspect-1"
+ }));
if index <= 3 {
assert!(sync_text.contains(RESTRICTION));
if matches!(context_path, ContextPath::ThreadOwned) {
@@ -652,7 +656,7 @@ async fn guardians_retain_evidence_after_compaction_and_discard_it_after_rollbac
compact_output.contains(&expected_output),
"{compact_output}"
);
- assert!(parent_input.contains(SUMMARY));
+ assert!(parent_items.contains(&checkpoint));
if matches!(context_path, ContextPath::ThreadOwned) {
assert!(
content.contains(RESTRICTION),
@@ -662,7 +666,8 @@ async fn guardians_retain_evidence_after_compaction_and_discard_it_after_rollbac
!transcript.contains(&expected_output),
"raw tool result must not survive the parent checkpoint"
);
- assert!(transcript.contains(SUMMARY));
+ assert!(transcript.contains(RESTRICTION));
+ assert!(!transcript.contains(SUMMARY));
} else {
assert!(
transcript.contains(RESTRICTION),
diff --git a/codex-rs/core/src/client.rs b/codex-rs/core/src/client.rs
index e3dff930d7..7bb6beecbf 100644
--- a/codex-rs/core/src/client.rs
+++ b/codex-rs/core/src/client.rs
@@ -1278,6 +1278,7 @@ impl Drop for ModelClientSession {
}
impl ModelClientSession {
+ #[expect(dead_code, reason = "the v1-only accessor is removed in the follow-up")]
pub(crate) fn turn_state(&self) -> Arc<OnceLock<String>> {
Arc::clone(&self.turn_state)
}
diff --git a/codex-rs/core/src/lib.rs b/codex-rs/core/src/lib.rs
index 68baeb5b41..50dcbbb514 100644
--- a/codex-rs/core/src/lib.rs
+++ b/codex-rs/core/src/lib.rs
@@ -29,6 +29,10 @@ pub use responses_metadata::CodexResponsesMetadata;
pub use turn_metadata::detached_memory_responses_metadata;
mod codex_thread;
mod compact_model_fallback;
+#[expect(
+ dead_code,
+ reason = "the unrouted v1 runner is removed in the follow-up"
+)]
mod compact_remote;
mod compact_remote_history;
mod compact_remote_v2;
diff --git a/codex-rs/core/src/session/mod.rs b/codex-rs/core/src/session/mod.rs
index bdd8f24c64..62f8766329 100644
--- a/codex-rs/core/src/session/mod.rs
+++ b/codex-rs/core/src/session/mod.rs
@@ -1088,28 +1088,20 @@ impl Session {
///
/// `ModelClient` is session-scoped and intentionally does not depend on the full `Config`, so
/// we precompute the comma-separated list of enabled experimental feature keys at session
- /// creation time and thread it into the client.
+ /// creation time and thread it into the client. Remote compaction stays advertised unconditionally.
fn build_model_client_beta_features_header(config: &Config) -> Option<String> {
- let beta_features_header = FEATURES
- .iter()
- .filter_map(|spec| {
- let advertise_in_model_client_header =
- spec.stage.experimental_menu_description().is_some()
- || spec.id == Feature::RemoteCompactionV2;
- if advertise_in_model_client_header && config.features.enabled(spec.id) {
- Some(spec.key)
- } else {
- None
- }
- })
- .collect::<Vec<_>>()
- .join(",");
-
- if beta_features_header.is_empty() {
- None
- } else {
- Some(beta_features_header)
- }
+ Some(
+ FEATURES
+ .iter()
+ .filter(|spec| {
+ spec.id == Feature::RemoteCompactionV2
+ || (spec.stage.experimental_menu_description().is_some()
+ && config.features.enabled(spec.id))
+ })
+ .map(|spec| spec.key)
+ .collect::<Vec<_>>()
+ .join(","),
+ )
}
async fn start_managed_network_proxy(
diff --git a/codex-rs/core/src/session/tests.rs b/codex-rs/core/src/session/tests.rs
index f50da45137..0cad00a520 100644
--- a/codex-rs/core/src/session/tests.rs
+++ b/codex-rs/core/src/session/tests.rs
@@ -11314,7 +11314,7 @@ async fn make_remote_compaction_session(
#[test_case(FirstAttempt::Succeeds; "primary succeeds")]
#[test_case(FirstAttempt::Retries; "fallback executes")]
#[tokio::test]
-async fn legacy_compaction_retains_only_the_selected_step(first_attempt: FirstAttempt) {
+async fn remote_compaction_v2_retains_only_the_selected_step(first_attempt: FirstAttempt) {
let server = responses::start_mock_server().await;
let (session, turn, events) = make_remote_compaction_session(&server.uri()).await;
session
@@ -11360,9 +11360,15 @@ async fn legacy_compaction_retains_only_the_selected_step(first_attempt: FirstAt
Some(Arc::as_ptr(&primary)),
);
- let success = ResponseTemplate::new(/*status*/ 200).set_body_json(json!({
- "output": [{ "type": "compaction", "encrypted_content": "summary" }]
- }));
+ let success = ResponseTemplate::new(/*status*/ 200)
+ .insert_header("content-type", "text/event-stream")
+ .set_body_string(responses::sse(vec![
+ json!({
+ "type": "response.output_item.done",
+ "item": { "type": "compaction", "encrypted_content": "summary" },
+ }),
+ responses::ev_completed("compact-response"),
+ ]));
let replies = match first_attempt {
FirstAttempt::Succeeds => vec![success],
FirstAttempt::Retries => vec![
@@ -11371,12 +11377,13 @@ async fn legacy_compaction_retains_only_the_selected_step(first_attempt: FirstAt
success,
],
};
- let requests = responses::mount_compact_response_sequence(&server, replies).await;
- crate::compact_remote::run_inline_remote_auto_compact_task(
+ let requests = responses::mount_response_sequence(&server, replies).await;
+ let mut client_session = session.services.model_client.new_session();
+ crate::compact_remote_v2::run_inline_remote_auto_compact_task(
Arc::clone(&session),
Arc::clone(&primary),
Some(Arc::clone(&fallback)),
- Arc::new(OnceLock::new()),
+ &mut client_session,
InitialContextInjection::DoNotInject,
CompactionReason::ModelDownshift,
CompactionPhase::PreTurn,
@@ -11405,6 +11412,12 @@ async fn legacy_compaction_retains_only_the_selected_step(first_attempt: FirstAt
.collect::<Vec<_>>(),
models,
);
+ assert!(
+ requests
+ .requests()
+ .iter()
+ .all(|request| request.inputs_of_type("compaction_trigger").len() == 1),
+ );
session.abort_all_tasks(TurnAbortReason::Interrupted).await;
recv_terminal_event(&events, TerminalEventKind::TurnAborted).await;
}
diff --git a/codex-rs/core/src/session/tests/guardian_tests.rs b/codex-rs/core/src/session/tests/guardian_tests.rs
index 5ca8c44a08..012da43b42 100644
--- a/codex-rs/core/src/session/tests/guardian_tests.rs
+++ b/codex-rs/core/src/session/tests/guardian_tests.rs
@@ -39,11 +39,9 @@ use codex_network_proxy::NetworkProtocol;
use codex_protocol::config_types::ApprovalsReviewer;
use codex_protocol::error::SandboxErr;
use codex_protocol::models::AdditionalPermissionProfile as PermissionProfile;
-use codex_protocol::models::ContentItem;
use codex_protocol::models::ContentItemKind;
use codex_protocol::models::NetworkPermissions;
use codex_protocol::models::ResponseInputItem;
-use codex_protocol::models::ResponseItem;
use codex_protocol::protocol::AskForApproval;
use codex_protocol::request_permissions::PermissionGrantScope;
use codex_protocol::request_permissions::RequestPermissionProfile;
@@ -1053,7 +1051,7 @@ async fn guardian_allows_unified_exec_additional_permissions_requests_past_polic
}
#[tokio::test]
-async fn process_compacted_history_preserves_separate_guardian_developer_message() {
+async fn compaction_initial_context_preserves_separate_guardian_developer_message() {
let (session, mut turn_context) = make_session_and_context().await;
update_turn_settings_for_test(&mut turn_context, |settings| {
update_selected_settings_for_test(settings, |selected| {
@@ -1084,40 +1082,20 @@ async fn process_compacted_history_preserves_separate_guardian_developer_message
step_context,
};
- let (refreshed, _) = crate::compact_remote::process_compacted_history(
- &session,
- vec![
- ResponseItem::Message {
- id: None,
- role: "developer".to_string(),
- content: vec![ContentItem::InputText {
- text: "stale developer message".to_string(),
- }],
- phase: None,
- internal_chat_message_metadata_passthrough: None,
- },
- ResponseItem::Message {
- id: None,
- role: "user".to_string(),
- content: vec![ContentItem::InputText {
- text: "summary".to_string(),
- }],
- phase: None,
- internal_chat_message_metadata_passthrough: None,
- },
- ],
- &initial_context_injection,
- )
- .await;
+ let (refreshed, _) =
+ crate::compact::build_compaction_initial_context(&session, &initial_context_injection)
+ .await;
let developer_messages = refreshed
.iter()
- .filter_map(|item| match item {
+ .filter_map(|envelope| match &envelope.item {
ResponseItem::Message { role, content, .. } if role == "developer" => {
crate::content_items_to_text(content).map(|text| {
(
text,
- item.executed_tool_call_metadata()
+ envelope
+ .item
+ .executed_tool_call_metadata()
.and_then(|metadata| metadata.content_item_kinds.clone()),
)
})
@@ -1126,11 +1104,6 @@ async fn process_compacted_history_preserves_separate_guardian_developer_message
})
.collect::<Vec<_>>();
- assert!(
- !developer_messages
- .iter()
- .any(|(message, _)| message.contains("stale developer message"))
- );
assert!(
!developer_messages
.iter()
diff --git a/codex-rs/core/src/session/turn.rs b/codex-rs/core/src/session/turn.rs
index 9127f3f031..c68e4a72a4 100644
--- a/codex-rs/core/src/session/turn.rs
+++ b/codex-rs/core/src/session/turn.rs
@@ -9,7 +9,6 @@ use crate::client_common::Prompt;
use crate::client_common::ResponseEvent;
use crate::compact::InitialContextInjection;
use crate::compact::run_inline_auto_compact_task;
-use crate::compact_remote::run_inline_remote_auto_compact_task;
use crate::compact_remote_v2::run_inline_remote_auto_compact_task as run_inline_remote_auto_compact_task_v2;
use crate::connectors;
use crate::context::ContextualUserFragment;
@@ -1315,12 +1314,7 @@ async fn run_auto_compact(
}
match turn_context.provider.capabilities().remote_compaction {
- RemoteCompactionSupport::V2
- if turn_context
- .config
- .features
- .enabled(Feature::RemoteCompactionV2) =>
- {
+ RemoteCompactionSupport::V2 => {
emit_compact_metric(
&sess.services.session_telemetry,
"remote_v2",
@@ -1337,23 +1331,6 @@ async fn run_auto_compact(
)
.await?;
}
- RemoteCompactionSupport::V2 => {
- emit_compact_metric(
- &sess.services.session_telemetry,
- "remote",
- /*manual*/ false,
- );
- run_inline_remote_auto_compact_task(
- Arc::clone(sess),
- step_context,
- fallback_step_context,
- client_session.turn_state(),
- initial_context_injection,
- reason,
- phase,
- )
- .await?;
- }
RemoteCompactionSupport::Unsupported => {
emit_compact_metric(
&sess.services.session_telemetry,
diff --git a/codex-rs/core/src/tasks/compact.rs b/codex-rs/core/src/tasks/compact.rs
index 99e2113485..14913d95c8 100644
--- a/codex-rs/core/src/tasks/compact.rs
+++ b/codex-rs/core/src/tasks/compact.rs
@@ -39,9 +39,7 @@ impl SessionTask for CompactTask {
}
let result = match ctx.provider.capabilities().remote_compaction {
- RemoteCompactionSupport::V2
- if ctx.config.features.enabled(Feature::RemoteCompactionV2) =>
- {
+ RemoteCompactionSupport::V2 => {
emit_compact_metric(
&session.services.session_telemetry,
"remote_v2",
@@ -49,14 +47,6 @@ impl SessionTask for CompactTask {
);
crate::compact_remote_v2::run_remote_compact_task(session.clone(), ctx).await
}
- RemoteCompactionSupport::V2 => {
- emit_compact_metric(
- &session.services.session_telemetry,
- "remote",
- /*manual*/ true,
- );
- crate::compact_remote::run_remote_compact_task(session.clone(), ctx).await
- }
RemoteCompactionSupport::Unsupported => {
emit_compact_metric(
&session.services.session_telemetry,
diff --git a/codex-rs/core/tests/suite/code_mode.rs b/codex-rs/core/tests/suite/code_mode.rs
index f641fbb920..e1b0bc558f 100644
--- a/codex-rs/core/tests/suite/code_mode.rs
+++ b/codex-rs/core/tests/suite/code_mode.rs
@@ -1242,9 +1242,6 @@ await new Promise(() => {});
.disable(Feature::ExecutedToolCallMetadata)
.expect("tool call metadata should be disabled");
}
- if oversized {
- let _ = config.features.disable(Feature::RemoteCompactionV2);
- }
})
.await?;
@@ -1280,14 +1277,34 @@ await new Promise(() => {});
let cell_id = extract_running_cell_id(text_item(&first_items, /*index*/ 0));
if oversized {
- responses::mount_compact_user_history_with_summary_once(&server, "compacted history")
- .await;
+ let compact = responses::mount_sse_once(
+ &server,
+ responses::sse(vec![
+ serde_json::json!({
+ "type": "response.output_item.done",
+ "item": {
+ "type": "compaction",
+ "encrypted_content": "compacted history",
+ },
+ }),
+ responses::ev_completed("resp-compact"),
+ ]),
+ )
+ .await;
test.codex.submit(Op::Compact).await?;
wait_for_event(&test.codex, |event| {
matches!(event, EventMsg::TurnComplete(_))
})
.await;
+ assert_eq!(
+ compact
+ .single_request()
+ .inputs_of_type("compaction_trigger")
+ .len(),
+ 1
+ );
+
let wait = responses::mount_function_call_agent_response(
&server,
"call-2",
@@ -4742,20 +4759,10 @@ async fn code_mode_node_repl_text_evidence_is_visible_only_to_guardian(
const OTHER_NODE_REPL_RESULT: &str = "ECHOING: guardian-visible-other-tool-result";
const UNRELATED_RESULT: &str = "ECHOING: guardian-hidden-unrelated-result";
const PRIVATE_IMAGE: &str = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR4nGP4z8DwHwAFAAH/iZk9HQAAAABJRU5ErkJggg==";
+ const COMPACTION_SUMMARY: &str = "Guardian browser evidence summary";
let server = responses::start_mock_server().await;
let mcp_server_bin = remote_aware_stdio_server_bin()?;
let reviewer_compaction = reviewer_constraint == Some("compaction");
- let compact = if reviewer_compaction {
- Some(
- responses::mount_compact_user_history_with_summary_once(
- &server,
- "Guardian browser evidence summary",
- )
- .await,
- )
- } else {
- None
- };
let check_detail = enhanced_transcripts && transcript_images && reviewer_constraint.is_none();
let mut large_image = Cursor::new(Vec::new());
if check_detail {
@@ -4798,7 +4805,6 @@ async fn code_mode_node_repl_text_evidence_is_visible_only_to_guardian(
.enable(Feature::CodeMode)
.expect("enable Code Mode");
if reviewer_compaction {
- config.features.disable(Feature::RemoteCompactionV2).expect("use remote compaction");
config
.features
.enable(Feature::TokenBudget)
@@ -4877,9 +4883,8 @@ await tools.exec_command({ cmd: "printf second", sandbox_permissions: "require_e
.replace("SNAPSHOT_PADDING", &snapshot_padding.to_string())
.replace("REVIEWER_COMPACTION", &reviewer_compaction.to_string())
.replace("LARGE_IMAGE", &check_detail.to_string());
- let response_mock = responses::mount_sse_sequence(
- &server,
- vec![
+ let response_mock = responses::mount_sse_sequence(&server, {
+ let mut response_bodies = vec![
sse(vec![
responses::ev_function_call_with_namespace(
"node-repl-call",
@@ -4913,13 +4918,25 @@ await tools.exec_command({ cmd: "printf second", sandbox_permissions: "require_e
ev_completed("resp-guardian")
},
]),
+ ];
+ if reviewer_compaction {
+ response_bodies.push(sse(vec![
+ serde_json::json!({
+ "type": "response.output_item.done",
+ "item": {"type": "compaction", "encrypted_content": COMPACTION_SUMMARY},
+ }),
+ ev_completed("resp-guardian-compact"),
+ ]));
+ }
+ response_bodies.extend([
sse(vec![
ev_assistant_message("guardian-again", r#"{"outcome":"allow"}"#),
ev_completed("resp-guardian-again"),
]),
sse(vec![ev_completed("resp-done")]),
- ],
- )
+ ]);
+ response_bodies
+ })
.await;
test.submit_text_turn(&format!("review a nested {repl_server} tool response"))
.await?;
@@ -4928,6 +4945,7 @@ await tools.exec_command({ cmd: "printf second", sandbox_permissions: "require_e
.iter()
.filter(|request| {
request.body_json()["client_metadata"]["x-openai-subagent"].as_str() == Some("guardian")
+ && request.inputs_of_type("compaction_trigger").is_empty()
})
.collect::<Vec<_>>();
assert_eq!(guardian_requests.len(), 2);
@@ -5012,8 +5030,13 @@ await tools.exec_command({ cmd: "printf second", sandbox_permissions: "require_e
reviewer_image_urls
}
);
- if let Some(compact) = compact {
- let compact_request = compact.single_request();
+ if reviewer_compaction {
+ let compact_requests = requests
+ .iter()
+ .filter(|request| !request.inputs_of_type("compaction_trigger").is_empty())
+ .collect::<Vec<_>>();
+ assert_eq!(compact_requests.len(), 1);
+ let compact_request = compact_requests[0];
assert!(
compact_request
.message_input_texts("user")
@@ -5022,7 +5045,7 @@ await tools.exec_command({ cmd: "printf second", sandbox_permissions: "require_e
);
assert_eq!(
guardian_requests[1].inputs_of_type("compaction")[0]["encrypted_content"],
- "Guardian browser evidence summary"
+ COMPACTION_SUMMARY
);
for request in &guardian_requests {
assert!(!request.has_content_kinds(&["token_budget.context_window"]));
diff --git a/codex-rs/core/tests/suite/compact.rs b/codex-rs/core/tests/suite/compact.rs
index ff313b31ac..4f324ade07 100644
--- a/codex-rs/core/tests/suite/compact.rs
+++ b/codex-rs/core/tests/suite/compact.rs
@@ -55,8 +55,6 @@ use core_test_support::responses::ev_assistant_message;
use core_test_support::responses::ev_completed;
use core_test_support::responses::ev_completed_with_tokens;
use core_test_support::responses::ev_function_call;
-use core_test_support::responses::mount_compact_json_once;
-use core_test_support::responses::mount_compact_response_sequence;
use core_test_support::responses::mount_response_sequence;
use core_test_support::responses::mount_sse_once;
use core_test_support::responses::mount_sse_once_match;
@@ -1021,6 +1019,8 @@ async fn reasoning_effort_override_remote_v2_compaction_resets_pinned_effort(
ev_assistant_message("m4", "third reply"),
ev_completed("r4"),
]),
+ sse(vec![ev_completed("r5")]),
+ sse(vec![ev_completed("r6")]),
],
)
.await;
@@ -1031,10 +1031,6 @@ async fn reasoning_effort_override_remote_v2_compaction_resets_pinned_effort(
model.use_responses_lite = true;
})
.with_config(move |config| {
- config
- .features
- .enable(Feature::RemoteCompactionV2)
- .expect("enable remote compaction v2");
config.model_provider.stream_max_retries = Some(0);
config.model_reasoning_effort = Some(ReasoningEffort::Medium);
config
@@ -1065,18 +1061,31 @@ async fn reasoning_effort_override_remote_v2_compaction_resets_pinned_effort(
})
.await;
test.submit_text_turn("after compaction").await?;
+ test.submit_text_turn("unchanged effort").await?;
+ core_test_support::submit_thread_settings(
+ &test.codex,
+ ThreadSettingsOverrides {
+ effort: Some(Some(ReasoningEffort::Low)),
+ ..Default::default()
+ },
+ )
+ .await?;
+ test.submit_text_turn("changed effort").await?;
let requests = request_log.requests();
- assert_eq!(requests.len(), 4);
+ assert_eq!(requests.len(), 6);
let first_body = requests[0].body_json();
let second_body = requests[1].body_json();
- let post_compaction_body = requests[3].body_json();
assert_eq!(first_body["reasoning"]["effort"], "medium");
assert_eq!(second_body["reasoning"]["effort"], "medium");
assert_eq!(requests[2].body_json()["reasoning"]["effort"], "medium");
+ let post_compaction_effort = if fail_compaction { "medium" } else { "high" };
assert_eq!(
- post_compaction_body["reasoning"]["effort"],
- if fail_compaction { "medium" } else { "high" }
+ requests[3..]
+ .iter()
+ .map(|request| request.body_json()["reasoning"]["effort"].clone())
+ .collect::<Vec<_>>(),
+ vec![json!(post_compaction_effort); 3],
);
let updates = requests
.iter()
@@ -1096,17 +1105,26 @@ async fn reasoning_effort_override_remote_v2_compaction_resets_pinned_effort(
"type": "configuration_update",
"reasoning": {"effort": "high"},
});
+ let low = json!({
+ "type": "configuration_update",
+ "reasoning": {"effort": "low"},
+ });
+ let retained = if fail_compaction {
+ vec![medium.clone(), high.clone()]
+ } else {
+ vec![]
+ };
+ let mut changed = retained.clone();
+ changed.push(low);
assert_eq!(
updates,
[
vec![medium.clone()],
vec![medium.clone(), high.clone()],
- vec![medium.clone(), high.clone()],
- if fail_compaction {
- vec![medium, high]
- } else {
- vec![]
- },
+ vec![medium, high],
+ retained.clone(),
+ retained,
+ changed,
]
);
@@ -2175,36 +2193,16 @@ async fn auto_compact_runs_after_resume_when_token_usage_is_over_limit() {
let limit = 200_000;
let over_limit_tokens = 250_000;
- let remote_summary = "REMOTE_COMPACT_SUMMARY";
-
- let compacted_history = vec![
- codex_protocol::models::ResponseItem::Message {
- id: None,
- role: "assistant".to_string(),
- content: vec![codex_protocol::models::ContentItem::OutputText {
- text: remote_summary.to_string(),
- }],
- phase: None,
- internal_chat_message_metadata_passthrough: None,
- },
- codex_protocol::models::ResponseItem::Compaction {
- id: None,
- encrypted_content: "ENCRYPTED_COMPACTION_SUMMARY".to_string(),
- internal_chat_message_metadata_passthrough: None,
- },
- ];
- let compact_mock =
- mount_compact_json_once(&server, serde_json::json!({ "output": compacted_history })).await;
+ let remote_summary = REMOTE_V2_SUMMARY;
let mut builder = test_codex().with_config(move |config| {
set_test_compact_prompt(config);
config.model_auto_compact_token_limit = Some(limit);
- let _ = config.features.disable(Feature::RemoteCompactionV2);
});
let initial = builder.build(&server).await.unwrap();
// A single over-limit completion should not auto-compact until the next user message.
- mount_sse_once(
+ let initial_response = mount_sse_once(
&server,
sse(vec![
ev_assistant_message("m1", FIRST_REPLY),
@@ -2214,29 +2212,28 @@ async fn auto_compact_runs_after_resume_when_token_usage_is_over_limit() {
.await;
initial.submit_turn("OVER_LIMIT_TURN").await.unwrap();
+ let initial_requests = initial_response.requests();
+ assert_eq!(initial_requests.len(), 1);
assert!(
- compact_mock.requests().is_empty(),
+ initial_requests[0]
+ .inputs_of_type("compaction_trigger")
+ .is_empty(),
"remote compaction should not run before the next user message"
);
let mut resume_builder = test_codex().with_config(move |config| {
set_test_compact_prompt(config);
config.model_auto_compact_token_limit = Some(limit);
- let _ = config.features.disable(Feature::RemoteCompactionV2);
});
let resumed = resume_builder.restart(&server, &initial).await.unwrap();
let follow_up_user = "AFTER_RESUME_USER";
+ let compact_turn = remote_v2_compaction_response();
let sse_follow_up = sse(vec![
ev_assistant_message("m2", FINAL_REPLY),
ev_completed("r2"),
]);
-
- let follow_up_matcher = move |req: &wiremock::Request| {
- let body = std::str::from_utf8(&req.body).unwrap_or("");
- body.contains(follow_up_user) && body.contains(remote_summary)
- };
- mount_sse_once_match(&server, follow_up_matcher, sse_follow_up).await;
+ let response_mock = mount_sse_sequence(&server, vec![compact_turn, sse_follow_up]).await;
resumed
.codex
@@ -2257,17 +2254,21 @@ async fn auto_compact_runs_after_resume_when_token_usage_is_over_limit() {
})
.await;
- let compact_requests = compact_mock.requests();
+ let requests = response_mock.requests();
assert_eq!(
- compact_requests.len(),
- 1,
- "remote compaction should run once after resume"
+ requests.len(),
+ 2,
+ "remote compaction should run once after resume before sampling"
);
assert_eq!(
- compact_requests[0].path(),
- "/v1/responses/compact",
- "remote compaction should hit the compact endpoint"
- );
+ requests[0].path(),
+ "/v1/responses",
+ "remote compaction should use the responses endpoint"
+ );
+ assert_eq!(requests[0].inputs_of_type("compaction_trigger").len(), 1);
+ let follow_up_body = requests[1].body_json().to_string();
+ assert!(follow_up_body.contains(follow_up_user));
+ assert!(follow_up_body.contains(remote_summary));
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
@@ -2956,112 +2957,6 @@ async fn pre_sampling_compact_falls_back_after_previous_model_invalid_request_on
);
}
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn pre_sampling_legacy_remote_compact_falls_back_after_previous_model_invalid_request() {
- skip_if_no_network!();
-
- let server = MockServer::start().await;
- let retired_model = "gpt-5.6";
- let previous_model_family = "gpt-5.6";
- let next_model = "gpt-5.5";
- let mut previous_model_info =
- model_info_with_context_window("gpt-5.4", /*context_window*/ 273_000);
- previous_model_info.slug = previous_model_family.to_string();
- let mut next_model_info =
- model_info_with_context_window("gpt-5.4", /*context_window*/ 125_000);
- next_model_info.slug = next_model.to_string();
-
- let models_mock = mount_models_once(
- &server,
- ModelsResponse {
- models: vec![previous_model_info, next_model_info],
- },
- )
- .await;
- let request_log = mount_sse_sequence(
- &server,
- vec![
- sse(vec![
- ev_assistant_message("m1", "before switch"),
- ev_completed_with_tokens("r1", /*total_tokens*/ 120_000),
- ]),
- sse(vec![
- ev_assistant_message("m3", "after switch"),
- ev_completed_with_tokens("r3", /*total_tokens*/ 100),
- ]),
- ],
- )
- .await;
- let compact_request_log = mount_compact_response_sequence(
- &server,
- vec![
- invalid_request_response("previous-model compaction was rejected"),
- wiremock::ResponseTemplate::new(/*status*/ 200)
- .insert_header("content-type", "application/json")
- .set_body_json(json!({
- "output": [{
- "type": "compaction",
- "encrypted_content": "DOWNSHIFT_SUMMARY",
- }],
- })),
- ],
- )
- .await;
-
- let model_provider = openai_model_provider(&server);
- let mut builder = test_codex()
- .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
- .with_model(retired_model)
- .with_config(move |config| {
- config.model_provider = model_provider;
- set_test_compact_prompt(config);
- let _ = config.features.disable(Feature::RemoteCompactionV2);
- });
- let test = builder.build(&server).await.expect("build test codex");
-
- test.codex
- .start_or_steer_turn(disabled_permission_user_turn(
- "before switch",
- test.cwd.path().to_path_buf(),
- retired_model.to_string(),
- ))
- .await
- .expect("submit first user turn");
- wait_for_event(&test.codex, |event| {
- matches!(event, EventMsg::TurnComplete(_))
- })
- .await;
-
- test.codex
- .start_or_steer_turn(disabled_permission_user_turn(
- "after switch",
- test.cwd.path().to_path_buf(),
- next_model.to_string(),
- ))
- .await
- .expect("submit smaller-model turn");
- assert_compaction_uses_turn_lifecycle_id(&test.codex).await;
-
- let requests = request_log.requests();
- let compact_requests = compact_request_log.requests();
- assert_eq!(models_mock.requests().len(), 1);
- assert_eq!(requests.len(), 2);
- assert_eq!(compact_requests.len(), 2);
- assert_eq!(
- requests[0].body_json()["model"].as_str(),
- Some(retired_model)
- );
- assert_eq!(
- compact_requests[0].body_json()["model"].as_str(),
- Some(retired_model)
- );
- assert_eq!(
- compact_requests[1].body_json()["model"].as_str(),
- Some(next_model)
- );
- assert_eq!(requests[1].body_json()["model"].as_str(), Some(next_model));
-}
-
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn pre_sampling_compact_keeps_unknown_previous_model_for_api_key_auth_and_custom_provider() {
skip_if_no_network!();
@@ -4771,8 +4666,10 @@ async fn auto_compact_body_after_prefix_still_caps_at_context_window() {
);
}
+#[test_case::test_case(false; "counts_encrypted_reasoning_before_last_user")]
+#[test_case::test_case(true; "compacts_after_reasoning_header_clears")]
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn auto_compact_counts_encrypted_reasoning_before_last_user() {
+async fn auto_compact_accounts_for_encrypted_reasoning(first_response_includes_reasoning: bool) {
skip_if_no_network!();
let server = start_mock_server().await;
@@ -4792,51 +4689,36 @@ async fn auto_compact_counts_encrypted_reasoning_before_last_user() {
ev_reasoning_item("post-reasoning", &["post"], &[&post_last_reasoning_content]),
ev_completed_with_tokens("r2", /*total_tokens*/ 80),
]);
+ let compact_turn = remote_v2_compaction_response();
let third_turn = sse(vec![
ev_assistant_message("m4", FINAL_REPLY),
ev_completed_with_tokens("r4", /*total_tokens*/ 1),
]);
- let request_log = mount_sse_sequence(
+ let request_log = mount_response_sequence(
&server,
vec![
// Turn 1: reasoning before last user (should count).
- first_turn,
- // Turn 2: reasoning after last user (should be ignored for compaction).
- second_turn,
+ if first_response_includes_reasoning {
+ sse_response(first_turn).insert_header("X-Reasoning-Included", "true")
+ } else {
+ sse_response(first_turn)
+ },
+ // Turn 2: reasoning after last user should be ignored; no header is returned.
+ sse_response(second_turn),
+ // Turn 3: compact the prior conversation before sampling.
+ sse_response(compact_turn),
// Turn 3: next user turn after remote compaction.
- third_turn,
+ sse_response(third_turn),
],
)
.await;
- let compacted_history = vec![
- codex_protocol::models::ResponseItem::Message {
- id: None,
- role: "assistant".to_string(),
- content: vec![codex_protocol::models::ContentItem::OutputText {
- text: "REMOTE_COMPACT_SUMMARY".to_string(),
- }],
- phase: None,
- internal_chat_message_metadata_passthrough: None,
- },
- codex_protocol::models::ResponseItem::Compaction {
- id: None,
- encrypted_content: "ENCRYPTED_COMPACTION_SUMMARY".to_string(),
- internal_chat_message_metadata_passthrough: None,
- },
- ];
- let compact_mock =
- mount_compact_json_once(&server, serde_json::json!({ "output": compacted_history })).await;
- let chatgpt_base_url = format!("{}/backend-api", server.uri());
-
let codex = test_codex()
.with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
- .with_config(move |config| {
- config.chatgpt_base_url = chatgpt_base_url;
+ .with_config(|config| {
set_test_compact_prompt(config);
config.model_auto_compact_token_limit = Some(300);
- let _ = config.features.disable(Feature::RemoteCompactionV2);
})
.build(&server)
.await
@@ -4853,135 +4735,41 @@ async fn auto_compact_counts_encrypted_reasoning_before_last_user() {
text_elements: Vec::new(),
}]))
.await
- .unwrap();
+ .expect("start user turn");
wait_for_event(&codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
if idx < 2 {
assert!(
- compact_mock.requests().is_empty(),
+ request_log
+ .requests()
+ .iter()
+ .all(|request| request.inputs_of_type("compaction_trigger").is_empty()),
"remote compaction should not run before the next user turn"
);
}
}
- let compact_requests = compact_mock.requests();
- assert_eq!(
- compact_requests.len(),
- 1,
- "remote compaction should run once after the second turn"
- );
- assert_eq!(
- compact_requests[0].path(),
- "/v1/responses/compact",
- "remote compaction should hit the compact endpoint"
- );
-
let requests = request_log.requests();
assert_eq!(
requests.len(),
- 3,
- "conversation should include three user turns"
+ 4,
+ "conversation should include three user turns and remote compaction"
);
+ assert_eq!(requests[2].path(), "/v1/responses");
+ assert_eq!(requests[2].inputs_of_type("compaction_trigger").len(), 1);
+ assert!(requests[3].inputs_of_type("compaction_trigger").is_empty());
let second_request_body = requests[1].body_json().to_string();
assert!(
- !second_request_body.contains("REMOTE_COMPACT_SUMMARY"),
+ !second_request_body.contains(REMOTE_V2_SUMMARY),
"second turn should not include compacted history"
);
- let third_request_body = requests[2].body_json().to_string();
+ let third_request_body = requests[3].body_json().to_string();
assert!(
- third_request_body.contains("REMOTE_COMPACT_SUMMARY")
- || third_request_body.contains(FINAL_REPLY),
- "third turn should include compacted history"
- );
- assert!(
- third_request_body.contains("ENCRYPTED_COMPACTION_SUMMARY"),
+ third_request_body.contains(REMOTE_V2_SUMMARY),
"third turn should include compaction summary item"
);
}
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn auto_compact_runs_when_reasoning_header_clears_between_turns() {
- skip_if_no_network!();
-
- let server = start_mock_server().await;
-
- let first_user = "SERVER_INCLUDED_FIRST";
- let second_user = "SERVER_INCLUDED_SECOND";
- let third_user = "SERVER_INCLUDED_THIRD";
-
- let pre_last_reasoning_content = "a".repeat(2_400);
- let post_last_reasoning_content = "b".repeat(4_000);
-
- let first_turn = sse(vec![
- ev_reasoning_item("pre-reasoning", &["pre"], &[&pre_last_reasoning_content]),
- ev_completed_with_tokens("r1", /*total_tokens*/ 10),
- ]);
- let second_turn = sse(vec![
- ev_reasoning_item("post-reasoning", &["post"], &[&post_last_reasoning_content]),
- ev_completed_with_tokens("r2", /*total_tokens*/ 80),
- ]);
- let third_turn = sse(vec![
- ev_assistant_message("m4", FINAL_REPLY),
- ev_completed_with_tokens("r4", /*total_tokens*/ 1),
- ]);
-
- let responses = vec![
- sse_response(first_turn).insert_header("X-Reasoning-Included", "true"),
- sse_response(second_turn),
- sse_response(third_turn),
- ];
- mount_response_sequence(&server, responses).await;
-
- let compacted_history = vec![
- codex_protocol::models::ResponseItem::Message {
- id: None,
- role: "assistant".to_string(),
- content: vec![codex_protocol::models::ContentItem::OutputText {
- text: "REMOTE_COMPACT_SUMMARY".to_string(),
- }],
- phase: None,
- internal_chat_message_metadata_passthrough: None,
- },
- codex_protocol::models::ResponseItem::Compaction {
- id: None,
- encrypted_content: "ENCRYPTED_COMPACTION_SUMMARY".to_string(),
- internal_chat_message_metadata_passthrough: None,
- },
- ];
- let compact_mock =
- mount_compact_json_once(&server, serde_json::json!({ "output": compacted_history })).await;
-
- let codex = test_codex()
- .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
- .with_config(|config| {
- set_test_compact_prompt(config);
- config.model_auto_compact_token_limit = Some(300);
- let _ = config.features.disable(Feature::RemoteCompactionV2);
- })
- .build(&server)
- .await
- .expect("build codex")
- .codex;
-
- for user in [first_user, second_user, third_user] {
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: user.into(),
- text_elements: Vec::new(),
- }]))
- .await
- .unwrap();
- wait_for_event(&codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
- }
-
- let compact_requests = compact_mock.requests();
- assert_eq!(
- compact_requests.len(),
- 1,
- "remote compaction should run once after the reasoning header clears"
- );
-}
-
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
// TODO(ccunningham): Update once pre-turn compaction includes incoming user input.
async fn snapshot_request_shape_pre_turn_compaction_including_incoming_user_message() {
diff --git a/codex-rs/core/tests/suite/compact_remote.rs b/codex-rs/core/tests/suite/compact_remote.rs
index 7de3e92541..628df83957 100644
--- a/codex-rs/core/tests/suite/compact_remote.rs
+++ b/codex-rs/core/tests/suite/compact_remote.rs
@@ -1,63 +1,32 @@
-use super::compact::allow_echo_commands;
-use core_test_support::test_codex::local_selections;
-use std::fs;
-use std::path::Path;
+//! Exercises streamed remote compaction, including the retained checkpoint and continuing history.
use anyhow::Context;
use anyhow::Result;
use base64::Engine;
use base64::engine::general_purpose::STANDARD as BASE64_STANDARD;
-use codex_config::test_support::CloudConfigBundleFixture;
use codex_core::StartThreadOptions;
use codex_core::TurnInputRequest;
-use codex_core::X_CODEX_ROUTING_HINT_HEADER;
-use codex_core::compact::SUMMARY_PREFIX;
use codex_features::Feature;
use codex_history::CodexHarnessMetadata;
use codex_history::InitialHistory;
use codex_history::RolloutItem;
use codex_login::CodexAuth;
-use codex_login::auth::AgentIdentityAuth;
-use codex_login::auth::AgentIdentityAuthRecord;
use codex_login::auth::BedrockApiKeyAuth;
use codex_model_provider_info::AMAZON_BEDROCK_GPT_5_5_MODEL_ID;
use codex_model_provider_info::AMAZON_BEDROCK_PROVIDER_ID;
use codex_model_provider_info::ModelProviderInfo;
use codex_protocol::AgentPath;
-use codex_protocol::account::PlanType as AccountPlanType;
-use codex_protocol::config_types::ServiceTier;
-use codex_protocol::dynamic_tools::DynamicToolCallOutputContentItem;
-use codex_protocol::dynamic_tools::DynamicToolFunctionSpec;
-use codex_protocol::dynamic_tools::DynamicToolNamespaceSpec;
-use codex_protocol::dynamic_tools::DynamicToolNamespaceTool;
-use codex_protocol::dynamic_tools::DynamicToolResponse;
-use codex_protocol::dynamic_tools::DynamicToolSpec;
-use codex_protocol::items::TurnItem;
use codex_protocol::models::ContentItem;
-use codex_protocol::models::FunctionCallOutputBody;
-use codex_protocol::models::FunctionCallOutputContentItem;
-use codex_protocol::models::FunctionCallOutputPayload;
-use codex_protocol::models::PermissionProfile;
use codex_protocol::models::ResponseItem;
-use codex_protocol::openai_models::InputModality;
-use codex_protocol::protocol::AskForApproval;
use codex_protocol::protocol::ConversationStartParams;
use codex_protocol::protocol::EventMsg;
use codex_protocol::protocol::InterAgentCommunication;
-use codex_protocol::protocol::ItemCompletedEvent;
-use codex_protocol::protocol::ItemStartedEvent;
use codex_protocol::protocol::Op;
use codex_protocol::protocol::RealtimeConversationRealtimeEvent;
use codex_protocol::protocol::RealtimeEvent;
use codex_protocol::protocol::RealtimeOutputModality;
use codex_protocol::protocol::ThreadHistoryMode;
-use codex_protocol::protocol::ThreadSettingsOverrides;
use codex_protocol::user_input::UserInput;
-use core_test_support::PathBufExt;
-use core_test_support::apps_test_server::configure_search_capable_model;
-use core_test_support::context_snapshot;
-use core_test_support::context_snapshot::ContextSnapshotOptions;
-use core_test_support::context_snapshot::ContextSnapshotRenderMode;
use core_test_support::responses;
use core_test_support::responses::mount_sse_once;
use core_test_support::responses::sse;
@@ -66,170 +35,30 @@ use core_test_support::skip_if_no_network;
use core_test_support::test_codex::TestCodexBuilder;
use core_test_support::test_codex::TestCodexHarness;
use core_test_support::test_codex::test_codex as base_test_codex;
-use core_test_support::test_path_buf;
use core_test_support::wait_for_event;
use core_test_support::wait_for_event_match;
use core_test_support::wait_for_event_with_timeout;
use pretty_assertions::assert_eq;
use serde_json::Value;
use serde_json::json;
+use std::fs;
+use std::path::Path;
use test_case::test_case;
use tokio::time::Duration;
use wiremock::ResponseTemplate;
-const CONTEXT_WINDOW_TRUNCATED_OUTPUT_MESSAGE: &str =
- "Output exceeded the available model context and was truncated";
-const TEST_WAV_SAMPLE_RATE: u32 = 8_000;
-
-fn pcm_wav_data_url(sample_count: u32) -> String {
- let padding = sample_count % 2;
- let mut bytes = Vec::new();
- bytes.extend_from_slice(b"RIFF");
- bytes.extend_from_slice(&(36 + sample_count + padding).to_le_bytes());
- bytes.extend_from_slice(b"WAVEfmt ");
- bytes.extend_from_slice(&16u32.to_le_bytes());
- bytes.extend_from_slice(&1u16.to_le_bytes());
- bytes.extend_from_slice(&1u16.to_le_bytes());
- bytes.extend_from_slice(&TEST_WAV_SAMPLE_RATE.to_le_bytes());
- bytes.extend_from_slice(&TEST_WAV_SAMPLE_RATE.to_le_bytes());
- bytes.extend_from_slice(&1u16.to_le_bytes());
- bytes.extend_from_slice(&8u16.to_le_bytes());
- bytes.extend_from_slice(b"data");
- bytes.extend_from_slice(&sample_count.to_le_bytes());
- bytes.resize(
- bytes.len() + sample_count as usize + padding as usize,
- /*value*/ 0,
- );
- format!("data:audio/wav;base64,{}", BASE64_STANDARD.encode(bytes))
-}
-
-fn approx_token_count(text: &str) -> i64 {
- i64::try_from(text.len().saturating_add(3) / 4).unwrap_or(i64::MAX)
-}
-
-fn estimate_compact_input_tokens(request: &responses::ResponsesRequest) -> i64 {
- request.input().into_iter().fold(0i64, |acc, item| {
- acc.saturating_add(approx_token_count(&item.to_string()))
- })
-}
-
-fn estimate_compact_payload_tokens(request: &responses::ResponsesRequest) -> i64 {
- estimate_compact_input_tokens(request)
- .saturating_add(approx_token_count(&request.instructions_text()))
-}
-
-fn assert_tools_payload_does_not_defer(body: &Value) {
- if let Some(tools) = body.get("tools") {
- assert!(
- !contains_defer_loading(tools),
- "model-visible tools should not include deferred declarations: {tools}"
- );
- }
-}
-
-fn namespace_child_tool_names(body: &Value, namespace: &str) -> Vec<String> {
- body.get("tools")
- .and_then(Value::as_array)
- .and_then(|tools| {
- tools.iter().find_map(|tool| {
- if tool.get("type").and_then(Value::as_str) == Some("namespace")
- && tool.get("name").and_then(Value::as_str) == Some(namespace)
- {
- tool.get("tools").and_then(Value::as_array).map(|children| {
- children
- .iter()
- .filter_map(|child| {
- child
- .get("name")
- .and_then(Value::as_str)
- .map(str::to_string)
- })
- .collect()
- })
- } else {
- None
- }
- })
- })
- .unwrap_or_default()
-}
-
-fn contains_defer_loading(value: &Value) -> bool {
- match value {
- Value::Object(map) => {
- map.get("defer_loading").and_then(Value::as_bool) == Some(true)
- || map.values().any(contains_defer_loading)
- }
- Value::Array(values) => values.iter().any(contains_defer_loading),
- Value::Null | Value::Bool(_) | Value::Number(_) | Value::String(_) => false,
- }
-}
-
-fn canonical_json(value: &Value) -> Value {
- match value {
- Value::Object(map) => {
- let mut entries = map.iter().collect::<Vec<_>>();
- entries.sort_by_key(|(left_key, _)| *left_key);
- Value::Object(
- entries
- .into_iter()
- .map(|(key, value)| (key.clone(), canonical_json(value)))
- .collect(),
- )
- }
- Value::Array(values) => Value::Array(values.iter().map(canonical_json).collect()),
- Value::Null | Value::Bool(_) | Value::Number(_) | Value::String(_) => value.clone(),
- }
-}
+#[path = "compact_remote_trimming.rs"]
+mod trimming;
-const PRETURN_CONTEXT_DIFF_CWD: &str = "/tmp/PRETURN_CONTEXT_DIFF_CWD";
const DUMMY_FUNCTION_NAME: &str = "test_tool";
const TURN_STATE_HEADER: &str = "x-codex-turn-state";
const REMOTE_COMPACT_TURN_COMPLETE_TIMEOUT: Duration = Duration::from_secs(30);
-const TEST_AGENT_IDENTITY_PRIVATE_KEY: &str =
- "MC4CAQAwBQYDK2VwBCIEIJ7kFBaOujmoz1gvBNEC+BeM2IX87FFB0xmISOZ/XO0c";
-
-fn summary_with_prefix(summary: &str) -> String {
- format!("{SUMMARY_PREFIX}\n{summary}")
-}
-
-fn context_snapshot_options() -> ContextSnapshotOptions {
- ContextSnapshotOptions::default()
- .strip_capability_instructions()
- .render_mode(ContextSnapshotRenderMode::KindWithTextPrefix { max_chars: 64 })
-}
-
-fn format_labeled_requests_snapshot(
- scenario: &str,
- sections: &[(&str, &responses::ResponsesRequest)],
-) -> String {
- context_snapshot::format_labeled_requests_snapshot(
- scenario,
- sections,
- &context_snapshot_options(),
- )
-}
-
-fn compacted_summary_only_output(summary: &str) -> Vec<ResponseItem> {
- vec![ResponseItem::Compaction {
- id: None,
- encrypted_content: summary_with_prefix(summary),
- internal_chat_message_metadata_passthrough: None,
- }]
-}
+const CONTEXT_WINDOW_TRUNCATED_OUTPUT_MESSAGE: &str =
+ "Output exceeded the available model context and was truncated";
fn test_codex() -> TestCodexBuilder {
base_test_codex().with_config(|config| {
config.update_plan_enabled = true;
- let _ = config.features.disable(Feature::RemoteCompactionV2);
- })
-}
-
-fn unrestricted_user_turn(items: Vec<UserInput>) -> TurnInputRequest {
- TurnInputRequest::user_input(items).with_thread_settings(ThreadSettingsOverrides {
- approval_policy: Some(AskForApproval::Never),
- permission_profile: Some(PermissionProfile::Disabled),
- ..Default::default()
})
}
@@ -322,14 +151,6 @@ async fn close_realtime_conversation(codex: &codex_core::CodexThread) -> Result<
Ok(())
}
-fn assert_request_contains_realtime_start(request: &responses::ResponsesRequest) {
- let body = request.body_json().to_string();
- assert!(
- body.contains("<realtime_conversation>"),
- "expected request to restate realtime instructions"
- );
-}
-
fn assert_request_contains_custom_realtime_start(
request: &responses::ResponsesRequest,
instructions: &str,
@@ -349,18 +170,6 @@ fn assert_request_contains_custom_realtime_start(
);
}
-fn assert_request_contains_realtime_end(request: &responses::ResponsesRequest) {
- let body = request.body_json().to_string();
- assert!(
- body.contains("<realtime_conversation>"),
- "expected request to restate realtime instructions"
- );
- assert!(
- body.contains("Realtime conversation ended."),
- "expected request to use realtime end instructions"
- );
-}
-
async fn wait_for_turn_complete(codex: &codex_core::CodexThread) {
wait_for_event_with_timeout(
codex,
@@ -458,76 +267,6 @@ fn assert_compact_request_omits_harness_metadata(request: &responses::ResponsesR
}
}
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn amazon_bedrock_manual_compaction_uses_v2_responses_endpoint() -> Result<()> {
- skip_if_no_network!(Ok(()));
-
- let harness = TestCodexHarness::with_auto_env_builder(amazon_bedrock_test_codex()).await?;
-
- let response_mock = responses::mount_sse_sequence(
- harness.server(),
- vec![
- sse(vec![
- responses::ev_assistant_message("message-1", "before compaction"),
- responses::ev_completed("response-1"),
- ]),
- sse(vec![
- json!({
- "type": "response.output_item.done",
- "item": {
- "type": "compaction",
- "encrypted_content": "BEDROCK_REMOTE_COMPACTED_SUMMARY",
- }
- }),
- responses::ev_completed("response-compact"),
- ]),
- sse(vec![
- responses::ev_assistant_message("message-2", "after compaction"),
- responses::ev_completed("response-2"),
- ]),
- ],
- )
- .await;
-
- harness.test().submit_turn("before compact").await?;
- harness.test().codex.submit(Op::Compact).await?;
- wait_for_turn_complete(&harness.test().codex).await;
- harness.test().submit_turn("after compact").await?;
-
- let response_requests = response_mock.requests();
- assert_eq!(response_requests.len(), 3);
- assert!(
- response_requests
- .iter()
- .all(|request| request.path() == "/v1/responses")
- );
- let compact_request = &response_requests[1];
- assert_eq!(
- compact_request.header("authorization").as_deref(),
- Some("Bearer bedrock-test-api-key")
- );
- assert_eq!(
- compact_request
- .header("x-amzn-mantle-client-agent")
- .as_deref(),
- Some("codex")
- );
- assert_eq!(
- compact_request.body_json()["model"],
- AMAZON_BEDROCK_GPT_5_5_MODEL_ID
- );
- assert_eq!(
- compact_request.inputs_of_type("compaction_trigger").len(),
- 1
- );
- assert!(response_requests[2].input().iter().any(|item| {
- item["type"] == "compaction"
- && item["encrypted_content"] == "BEDROCK_REMOTE_COMPACTED_SUMMARY"
- }));
-
- Ok(())
-}
-
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn remote_compact_v2_retains_metadata_from_resumed_history() -> Result<()> {
skip_if_no_network!(Ok(()));
@@ -551,18 +290,22 @@ async fn remote_compact_v2_retains_metadata_from_resumed_history() -> Result<()>
}),
responses::ev_completed("response-compact"),
]),
+ sse(vec![responses::ev_completed("response-after")]),
],
)
.await;
- let builder = || {
- test_codex()
- .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
- .with_config(|config| {
- let _ = config.features.enable(Feature::RemoteCompactionV2);
- })
- };
- let initial = builder().build(&server).await?;
+ let builder = || test_codex().with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing());
+ let initial = builder()
+ .with_pre_build_hook(|home| {
+ fs::write(
+ home.join("config.toml"),
+ "[features]\nremote_compaction_v2 = false\n",
+ )
+ .expect("write saved config");
+ })
+ .build(&server)
+ .await?;
initial.submit_turn(retained_text).await?;
let home = initial.home.clone();
let rollout_path = initial
@@ -578,16 +321,22 @@ async fn remote_compact_v2_retains_metadata_from_resumed_history() -> Result<()>
.await?;
resumed.codex.submit(Op::Compact).await?;
wait_for_turn_complete(&resumed.codex).await;
+ resumed.submit_turn("continue after compaction").await?;
resumed.codex.shutdown_and_wait().await?;
let requests = response_mock.requests();
- let compact_request = requests.last().context("compact request")?;
+ let compact_request = &requests[1];
assert_eq!(
compact_request.inputs_of_type("compaction_trigger").len(),
1
);
assert_compact_request_omits_harness_metadata(compact_request);
assert_compacted_user_metadata(&rollout_path, retained_text)?;
+ assert_eq!(
+ requests[2].inputs_of_type("compaction")[0]["encrypted_content"],
+ "ANNOTATED_V2_COMPACTION_SUMMARY"
+ );
+ assert!(requests[2].body_contains_text("continue after compaction"));
Ok(())
}
@@ -827,3662 +576,837 @@ async fn amazon_bedrock_automatic_compaction_uses_v2_responses_endpoint() -> Res
Ok(())
}
+#[test_case(None; "default_trims_images")]
+#[test_case(Some(false); "disabled_preserves_images")]
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn remote_compact_replaces_history_for_followups() -> Result<()> {
+async fn remote_compact_v2_charges_retained_images_to_token_budget(
+ image_budget_enabled: Option<bool>,
+) -> Result<()> {
skip_if_no_network!(Ok(()));
- let harness = TestCodexHarness::with_builder(
+ let harness = TestCodexHarness::with_auto_env_builder(
test_codex()
- .with_history_mode(ThreadHistoryMode::Paginated)
- .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing()),
+ .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
+ .with_config(move |config| {
+ let _ = config.features.enable(Feature::RemoteCompactionV2);
+ let _ = config.features.enable(Feature::UnifiedImageBudget);
+ if let Some(enabled) = image_budget_enabled {
+ let _ = config
+ .features
+ .set_enabled(Feature::CompactionImageBudget, enabled);
+ }
+ }),
)
.await?;
- let codex = harness.test().codex.clone();
- let session_id = harness.test().session_configured.session_id.to_string();
- let thread_id = harness.test().session_configured.thread_id.to_string();
-
- let responses_mock = responses::mount_sse_sequence(
- harness.server(),
- vec![
- responses::sse(vec![
- responses::ev_assistant_message("m1", "FIRST_REMOTE_REPLY"),
- responses::ev_completed("resp-1"),
- ]),
- responses::sse(vec![
- responses::ev_assistant_message("m2", "AFTER_COMPACT_REPLY"),
- responses::ev_completed("resp-2"),
- ]),
- ],
- )
- .await;
-
- let compacted_history = vec![ResponseItem::Compaction {
- id: None,
- encrypted_content: "ENCRYPTED_COMPACTION_SUMMARY".to_string(),
- internal_chat_message_metadata_passthrough: None,
- }];
- let compact_mock = responses::mount_compact_json_once(
+ let codex = &harness.test().codex;
+ // Each original-detail image costs 10,000 estimated patch tokens.
+ let image_inputs = (1..=8)
+ .map(|number| {
+ let image = image::ImageBuffer::from_pixel(
+ /*width*/ 3200,
+ /*height*/ 3200,
+ image::Luma([number as u8]),
+ );
+ let mut bytes = std::io::Cursor::new(Vec::new());
+ image.write_to(&mut bytes, image::ImageFormat::Png)?;
+ Ok(UserInput::Image {
+ image_url: format!(
+ "data:image/png;base64,{}",
+ BASE64_STANDARD.encode(bytes.get_ref())
+ ),
+ detail: Some(codex_protocol::models::ImageDetail::Original),
+ })
+ })
+ .collect::<Result<Vec<_>>>()?;
+ let mut input = image_inputs[..7].to_vec();
+ input.push(UserInput::Text {
+ text: "Compare these images".to_string(),
+ text_elements: Vec::new(),
+ });
+ let initial_mock = mount_sse_once(
harness.server(),
- serde_json::json!({ "output": compacted_history.clone() }),
+ sse(vec![
+ responses::ev_assistant_message("initial", "done"),
+ responses::ev_completed("initial"),
+ ]),
)
.await;
-
codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "hello remote compact".into(),
- text_elements: Vec::new(),
- }]))
+ .start_or_steer_turn(TurnInputRequest::user_input(input))
.await?;
- wait_for_turn_complete(&codex).await;
-
- codex.submit(Op::Compact).await?;
- wait_for_turn_complete(&codex).await;
+ wait_for_turn_complete(codex).await;
+ let initial_request = initial_mock.single_request();
+ let prepared_images = initial_request.message_input_image_urls("user");
+ assert_eq!(prepared_images.len(), 7);
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "after compact".into(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_turn_complete(&codex).await;
+ for cycle in 1..=2 {
+ let compact_mock = mount_sse_once(
+ harness.server(),
+ sse(vec![
+ json!({
+ "type": "response.output_item.done",
+ "item": { "type": "compaction", "encrypted_content": "IMAGE_BUDGET_SUMMARY" },
+ }),
+ responses::ev_completed("compact-images"),
+ ]),
+ )
+ .await;
+ codex.submit(Op::Compact).await?;
+ wait_for_turn_complete(codex).await;
+ let compact_request = compact_mock.single_request();
+ assert_eq!(compact_request.path(), "/v1/responses");
+ assert_eq!(
+ compact_request.inputs_of_type("compaction_trigger").len(),
+ 1
+ );
- let compact_request = compact_mock.single_request();
- assert_eq!(compact_request.path(), "/v1/responses/compact");
- assert_eq!(
- compact_request.header("chatgpt-account-id").as_deref(),
- Some("account_id")
- );
- assert_eq!(
- compact_request.header("authorization").as_deref(),
- Some("Bearer Access Token")
- );
- assert_eq!(
- compact_request.header("session-id").as_deref(),
- Some(session_id.as_str())
- );
- assert_eq!(
- compact_request.header("thread-id").as_deref(),
- Some(thread_id.as_str())
- );
- let compact_metadata: Value = serde_json::from_str(
- &compact_request
- .header("x-codex-turn-metadata")
- .expect("remote compact request should include turn metadata"),
- )
- .expect("remote compact turn metadata should be valid json");
- assert_eq!(
- compact_request.header("x-codex-installation-id").as_deref(),
- compact_metadata["installation_id"].as_str()
- );
- assert!(
- compact_metadata["turn_id"]
- .as_str()
- .is_some_and(|id| !id.is_empty()),
- "remote compact turn metadata should include its turn id"
- );
- assert_eq!(
- compact_metadata["request_kind"].as_str(),
- Some("compaction")
- );
- assert_eq!(compact_metadata["sandbox_mode"].as_str(), Some("read-only"));
- assert_eq!(
- compact_metadata["window_id"].as_str(),
- compact_request.header("x-codex-window-id").as_deref()
- );
- assert_eq!(compact_metadata["window_number"].as_u64(), Some(0));
- assert!(compact_metadata["context_window_id"].as_str().is_some());
- assert_eq!(
- compact_metadata["compaction"],
- json!({
- "trigger": "manual",
- "reason": "user_requested",
- "implementation": "responses_compact",
- "phase": "standalone_turn",
- "strategy": "memento",
- })
- );
- let compact_body = compact_request.body_json();
- assert_eq!(
- compact_body.get("model").and_then(|v| v.as_str()),
- Some(harness.test().session_configured.model.as_str())
- );
- let response_requests = responses_mock.requests();
- let first_response_request = response_requests.first().expect("initial request missing");
- let first_response_metadata: Value = serde_json::from_str(
- &first_response_request
- .header("x-codex-turn-metadata")
- .expect("initial request should include turn metadata"),
- )
- .expect("initial turn metadata should be valid json");
- assert_ne!(
- first_response_metadata["turn_id"], compact_metadata["turn_id"],
- "manual compaction should use its own turn id"
- );
- assert_eq!(
- first_response_metadata["context_window_id"], compact_metadata["context_window_id"],
- "remote compaction should retain the active model-visible context window"
- );
- assert_eq!(
- compact_body["tools"],
- first_response_request.body_json()["tools"],
- "compact requests should send the same tools payload as /v1/responses"
- );
- assert_eq!(
- compact_body["parallel_tool_calls"],
- first_response_request.body_json()["parallel_tool_calls"],
- "compact requests should match /v1/responses parallel_tool_calls"
- );
- assert_eq!(
- compact_body["reasoning"],
- first_response_request.body_json()["reasoning"],
- "compact requests should match /v1/responses reasoning"
- );
- assert_eq!(
- compact_body["text"],
- first_response_request.body_json()["text"],
- "compact requests should match /v1/responses text controls"
- );
- let compact_body_text = compact_body.to_string();
- assert!(
- compact_body_text.contains("hello remote compact"),
- "expected compact request to include user history"
- );
- assert!(
- compact_body_text.contains("FIRST_REMOTE_REPLY"),
- "expected compact request to include assistant history"
- );
-
- let response_requests = responses_mock.requests();
- let follow_up_request = response_requests.last().expect("follow-up request missing");
- let follow_up_metadata: Value = serde_json::from_str(
- &follow_up_request
- .header("x-codex-turn-metadata")
- .expect("follow-up request should include turn metadata"),
- )
- .expect("follow-up turn metadata should be valid json");
- assert_eq!(
- follow_up_metadata["request_kind"].as_str(),
- Some("turn"),
- "regular requests after compaction should remain turn requests"
- );
- assert!(
- follow_up_metadata.get("compaction").is_none(),
- "regular requests after compaction should not be marked as compact requests"
- );
- assert_ne!(
- follow_up_metadata["turn_id"], compact_metadata["turn_id"],
- "the following user turn should not reuse a manual compact turn id"
- );
- assert_eq!(
- follow_up_metadata["window_id"].as_str(),
- follow_up_request.header("x-codex-window-id").as_deref()
- );
- assert_ne!(
- follow_up_metadata["window_id"], compact_metadata["window_id"],
- "the following user turn should use the new compacted context window"
- );
- assert_ne!(
- follow_up_metadata["context_window_id"], compact_metadata["context_window_id"],
- "the following user turn should expose the new model-visible context window"
- );
- let follow_up_body = follow_up_request.body_json().to_string();
- assert!(
- follow_up_body.contains("\"type\":\"compaction\""),
- "expected follow-up request to use compacted history"
- );
- assert!(
- follow_up_body.contains("ENCRYPTED_COMPACTION_SUMMARY"),
- "expected follow-up request to include compaction summary item"
- );
- assert!(
- !follow_up_body.contains("FIRST_REMOTE_REPLY"),
- "expected follow-up request to drop pre-compaction assistant messages"
- );
- assert!(
- !follow_up_body.contains("hello remote compact"),
- "expected follow-up request to drop compacted-away user turns when remote output omits them"
- );
-
- insta::assert_snapshot!(
- "remote_manual_compact_with_history_shapes",
- format_labeled_requests_snapshot(
- "Remote manual /compact where remote compact output is compaction-only: follow-up layout uses the returned compaction item plus new user message.",
- &[
- ("Remote Compaction Request", &compact_request),
- ("Remote Post-Compaction History Layout", follow_up_request),
- ]
+ let follow_up_mock = mount_sse_once(
+ harness.server(),
+ sse(vec![
+ responses::ev_assistant_message("after", "done"),
+ responses::ev_completed("after"),
+ ]),
)
- );
+ .await;
+ codex
+ .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
+ text: "after compact".to_string(),
+ text_elements: Vec::new(),
+ }]))
+ .await?;
+ wait_for_turn_complete(codex).await;
+ let follow_up = follow_up_mock.single_request();
+ assert_eq!(
+ follow_up.inputs_of_type("compaction")[0]["encrypted_content"],
+ "IMAGE_BUDGET_SUMMARY"
+ );
+ let dropped = if image_budget_enabled.unwrap_or(true) {
+ cycle
+ } else {
+ 0
+ };
+ let mut expected_images = prepared_images[dropped..].to_vec();
+ if cycle == 2 {
+ let UserInput::Image { image_url, .. } = &image_inputs[7] else {
+ unreachable!()
+ };
+ expected_images.push(image_url.clone());
+ }
+ assert_eq!(follow_up.message_input_image_urls("user"), expected_images);
+ assert!(
+ follow_up
+ .message_input_texts("user")
+ .iter()
+ .any(|text| text == "Compare these images")
+ );
+ if cycle == 1 {
+ let append_mock = mount_sse_once(
+ harness.server(),
+ sse(vec![
+ responses::ev_assistant_message("append", "done"),
+ responses::ev_completed("append"),
+ ]),
+ )
+ .await;
+ codex
+ .start_or_steer_turn(TurnInputRequest::user_input(vec![image_inputs[7].clone()]))
+ .await?;
+ wait_for_turn_complete(codex).await;
+ let _ = append_mock.single_request();
+ }
+ }
Ok(())
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn remote_compact_uses_agent_identity_assertion() -> Result<()> {
+async fn remote_compact_v2_reuses_compaction_trigger_for_followups() -> Result<()> {
skip_if_no_network!(Ok(()));
let harness = TestCodexHarness::with_builder(
- test_codex().with_auth(CodexAuth::AgentIdentity(
- AgentIdentityAuth::from_record(
- AgentIdentityAuthRecord {
- agent_runtime_id: "agent-runtime-compact".to_string(),
- agent_private_key: TEST_AGENT_IDENTITY_PRIVATE_KEY.to_string(),
- account_id: "account-compact".to_string(),
- chatgpt_user_id: "user-compact".to_string(),
- email: Some("[email protected]".to_string()),
- plan_type: AccountPlanType::Plus,
- chatgpt_account_is_fedramp: false,
- task_id: Some("task-compact".to_string()),
- },
- "https://auth.openai.com/api/accounts",
- &codex_login::test_support::transport_default_auth_route_config(),
- )
- .await?,
- )),
+ test_codex()
+ .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
+ .with_config(|config| {
+ let _ = config.features.enable(Feature::RemoteCompactionV2);
+ }),
)
.await?;
- let codex = harness.test().codex.clone();
-
- let _responses_mock = responses::mount_sse_once(
- harness.server(),
- responses::sse(vec![
- responses::ev_assistant_message("m1", "REMOTE_REPLY"),
- responses::ev_completed("resp-1"),
- ]),
- )
- .await;
- let compact_mock = responses::mount_compact_json_once(
- harness.server(),
- serde_json::json!({ "output": compacted_summary_only_output("COMPACTED") }),
- )
- .await;
-
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "hello remote compact".into(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_turn_complete(&codex).await;
-
- codex.submit(Op::Compact).await?;
- wait_for_turn_complete(&codex).await;
-
- let compact_request = compact_mock.single_request();
- assert_eq!(compact_request.path(), "/v1/responses/compact");
- assert!(
- compact_request
- .header("authorization")
- .is_some_and(|value| value.starts_with("AgentAssertion ")),
- "compact request should use task-scoped AgentAssertion auth"
- );
- assert_eq!(
- compact_request.header("chatgpt-account-id").as_deref(),
- Some("account-compact")
- );
- let compact_body = compact_request.body_json();
- let model = compact_body["model"]
- .as_str()
- .expect("missing request model");
- assert_eq!(
- compact_request.header(X_CODEX_ROUTING_HINT_HEADER),
- Some(format!("model={model}"))
- );
-
- Ok(())
-}
-
-async fn assert_remote_manual_compact_request_parity(
- auth: CodexAuth,
- configured_service_tier: Option<ServiceTier>,
- expected_service_tier: Option<&str>,
- snapshot_name: &str,
- scenario: &str,
-) -> Result<()> {
- let uses_codex_backend = auth.uses_codex_backend();
- let mut builder = test_codex()
- .with_auth(auth)
- .with_pre_build_hook(allow_echo_commands);
- if let Some(service_tier) = configured_service_tier {
- builder = builder.with_config(move |config| {
- config.service_tier = Some(service_tier.request_value().to_string());
- });
- }
- let harness = TestCodexHarness::with_builder(builder).await?;
- let codex = harness.test().codex.clone();
- let image_url =
- "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR4nGNgYAAAAAMAASsJTYQAAAAASUVORK5CYII="
- .to_string();
+ let image_url = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR4nGNgYAAAAAMAASsJTYQAAAAASUVORK5CYII=";
+ let user_notice = "<image_resize_notice>retained user image</image_resize_notice>";
+ let tool_notice = "<image_resize_notice>discarded tool image</image_resize_notice>";
+ let unlisted_notice = "<unlisted_notice>discarded developer notice</unlisted_notice>";
+ let developer_message = |text| {
+ json!({
+ "type": "message",
+ "role": "developer",
+ "content": [{ "type": "input_text", "text": text }]
+ })
+ };
+ let initial_history = [
+ json!({
+ "type": "message",
+ "role": "user",
+ "content": [
+ { "type": "input_text", "text": "retained image source" },
+ { "type": "input_image", "image_url": image_url }
+ ]
+ }),
+ developer_message(user_notice),
+ developer_message(unlisted_notice),
+ json!({
+ "type": "function_call",
+ "name": "view_image",
+ "arguments": "{}",
+ "call_id": "image-call"
+ }),
+ json!({
+ "type": "function_call_output",
+ "call_id": "image-call",
+ "output": [{ "type": "input_image", "image_url": image_url }]
+ }),
+ developer_message(tool_notice),
+ ]
+ .into_iter()
+ .map(|item| {
+ serde_json::from_value::<ResponseItem>(item)
+ .map(|item| RolloutItem::ResponseItem(item.into()))
+ })
+ .collect::<serde_json::Result<Vec<_>>>()?;
+ let codex = harness
+ .test()
+ .thread_manager
+ .start_thread(StartThreadOptions {
+ initial_history: InitialHistory::Forked(initial_history),
+ ..StartThreadOptions::new(harness.test().config.clone())
+ })
+ .await?
+ .thread;
let responses_mock = responses::mount_sse_sequence(
harness.server(),
vec![
responses::sse(vec![
- responses::ev_assistant_message("turn-one-assistant", "TURN_ONE_ASSISTANT"),
- responses::ev_completed("turn-one-response"),
- ]),
- responses::sse(vec![
- responses::ev_reasoning_item(
- "turn-two-reasoning",
- &["TURN_TWO_REASONING"],
- &["turn two raw content"],
- ),
- responses::ev_assistant_message("turn-two-assistant", "TURN_TWO_ASSISTANT"),
- responses::ev_completed("turn-two-response"),
- ]),
- responses::sse(vec![
- responses::ev_function_call("turn-three-call", DUMMY_FUNCTION_NAME, "{}"),
- responses::ev_completed("turn-three-call-response"),
+ responses::ev_assistant_message("m1", "FIRST_REMOTE_REPLY"),
+ responses::ev_completed("resp-1"),
]),
responses::sse(vec![
- responses::ev_assistant_message("turn-three-assistant", "TURN_THREE_ASSISTANT"),
- responses::ev_completed("turn-three-final-response"),
+ responses::ev_assistant_message("m-agent", "DELEGATED_TASK_REPLY"),
+ responses::ev_completed("resp-agent"),
]),
responses::sse(vec![
- responses::ev_exec_command_call(
- "turn-four-exec-command",
- "echo TURN_FOUR_LOCAL_SHELL",
- ),
- responses::ev_completed("turn-four-local-shell-response"),
+ responses::ev_assistant_message("m-descendant", "DESCENDANT_FOLLOWUP_REPLY"),
+ responses::ev_completed("resp-descendant"),
]),
responses::sse(vec![
- responses::ev_assistant_message("turn-four-assistant", "TURN_FOUR_ASSISTANT"),
- responses::ev_completed("turn-four-final-response"),
+ responses::ev_assistant_message("m-compact-noise", "IGNORED_COMPACT_REPLY"),
+ serde_json::json!({
+ "type": "response.output_item.done",
+ "item": {
+ "type": "compaction",
+ "encrypted_content": "ENCRYPTED_CONTEXT_COMPACTION_SUMMARY",
+ }
+ }),
+ responses::ev_completed("resp-compact"),
]),
responses::sse(vec![
- responses::ev_reasoning_item(
- "turn-five-reasoning",
- &["TURN_FIVE_REASONING"],
- &["turn five raw content"],
- ),
- responses::ev_assistant_message("turn-five-assistant", "TURN_FIVE_ASSISTANT"),
- responses::ev_completed("turn-five-response"),
+ responses::ev_assistant_message("m2", "AFTER_COMPACT_REPLY"),
+ responses::ev_completed("resp-2"),
]),
],
)
.await;
- let compact_mock = responses::mount_compact_user_history_with_summary_once(
- harness.server(),
- "REMOTE_CACHE_TIER_SUMMARY",
- )
- .await;
codex
- .start_or_steer_turn(unrestricted_user_turn(vec![UserInput::Text {
- text: "TURN_ONE_USER".to_string(),
+ .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
+ text: "hello remote compact".into(),
text_elements: Vec::new(),
}]))
.await?;
wait_for_turn_complete(&codex).await;
codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![
- UserInput::Text {
- text: "TURN_TWO_PREFIX".to_string(),
- text_elements: Vec::new(),
- },
- UserInput::Text {
- text: "TURN_TWO_SUFFIX".to_string(),
- text_elements: Vec::new(),
- },
- ]))
- .await?;
- wait_for_turn_complete(&codex).await;
-
+ .submit(Op::InterAgentCommunication {
+ communication: InterAgentCommunication::new(
+ AgentPath::root().join("child").expect("valid child path"),
+ AgentPath::root(),
+ Vec::new(),
+ "Message Type: MESSAGE\nTask name: /root\nSender: /root/child\nPayload:\nchild progress"
+ .to_string(),
+ /*trigger_turn*/ false,
+ ),
+ start_options: Default::default(),
+ })
+ .await?;
codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "TURN_THREE_TOOL_USER".to_string(),
- text_elements: Vec::new(),
- }]))
+ .submit(Op::InterAgentCommunication {
+ communication: InterAgentCommunication::new(
+ AgentPath::root().join("child").expect("valid child path"),
+ AgentPath::root(),
+ Vec::new(),
+ "Message Type: FINAL_ANSWER\nTask name: /root\nSender: /root/child\nPayload:\nchild completion".to_string(),
+ /*trigger_turn*/ false,
+ ),
+ start_options: Default::default(),
+ })
+ .await?;
+ let delegated_task_ciphertext = format!("delegated compact task{}", "x".repeat(40_000));
+ codex
+ .submit(Op::InterAgentCommunication {
+ communication: InterAgentCommunication::new_encrypted(
+ AgentPath::root(),
+ AgentPath::root().join("worker").expect("valid worker path"),
+ Vec::new(),
+ delegated_task_ciphertext.clone(),
+ /*trigger_turn*/ true,
+ ),
+ start_options: Default::default(),
+ })
.await?;
wait_for_turn_complete(&codex).await;
+ let descendant_followup_ciphertext = "descendant follow-up task";
+ let worker_path = AgentPath::root().join("worker").expect("valid worker path");
codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![
- UserInput::Image {
- image_url,
- detail: None,
- },
- UserInput::Text {
- text: "TURN_FOUR_IMAGE_USER".to_string(),
- text_elements: Vec::new(),
- },
- ]))
+ .submit(Op::InterAgentCommunication {
+ communication: InterAgentCommunication::new_encrypted(
+ worker_path.join("child").expect("valid grandchild path"),
+ worker_path,
+ Vec::new(),
+ descendant_followup_ciphertext.to_string(),
+ /*trigger_turn*/ true,
+ ),
+ start_options: Default::default(),
+ })
.await?;
wait_for_turn_complete(&codex).await;
+ let compact_turn_id = codex.submit(Op::Compact).await?;
+ wait_for_turn_complete(&codex).await;
+
codex
.start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "TURN_FIVE_USER".to_string(),
+ text: "after compact".into(),
text_elements: Vec::new(),
}]))
.await?;
wait_for_turn_complete(&codex).await;
- let compact_turn_id = codex.submit(Op::Compact).await?;
- wait_for_turn_complete(&codex).await;
-
let response_requests = responses_mock.requests();
- assert_eq!(
- response_requests.len(),
- 7,
- "expected five turns with one unsupported tool continuation and one shell command continuation"
+ let compact_request = &response_requests[3];
+ let item_create_time = |request: &responses::ResponsesRequest, text: &str| {
+ request
+ .input()
+ .into_iter()
+ .find(|item| {
+ item["content"].as_array().is_some_and(|content| {
+ content.iter().any(|part| {
+ part["text"].as_str() == Some(text)
+ || part["encrypted_content"].as_str() == Some(text)
+ })
+ })
+ })
+ .and_then(|item| {
+ item.pointer("/internal_chat_message_metadata_passthrough/create_time")
+ .cloned()
+ })
+ .expect("matching message should include a creation timestamp")
+ };
+ let original_user_create_time = item_create_time(&response_requests[0], "hello remote compact");
+ let delegated_task_create_time =
+ item_create_time(&response_requests[1], &delegated_task_ciphertext);
+ assert!(
+ compact_request
+ .inputs_of_type("agent_message")
+ .iter()
+ .any(|item| item["content"][1]["encrypted_content"].as_str()
+ == Some(delegated_task_ciphertext.as_str())),
+ "expected v2 compaction input to include the encrypted delegated task"
);
- assert_eq!(
- compact_mock.requests().len(),
- 1,
- "expected exactly one remote compact request"
+ assert!(
+ compact_request
+ .inputs_of_type("agent_message")
+ .iter()
+ .any(|item| item["content"][1]["encrypted_content"].as_str()
+ == Some(descendant_followup_ciphertext)),
+ "expected v2 compaction input to include the descendant-authored follow-up task"
+ );
+ assert!(
+ compact_request
+ .inputs_of_type("agent_message")
+ .iter()
+ .any(|item| item.to_string().contains("child progress")),
+ "expected v2 compaction input to include the child progress update"
+ );
+ assert!(
+ compact_request
+ .inputs_of_type("agent_message")
+ .iter()
+ .any(|item| item.to_string().contains("child completion")),
+ "expected v2 compaction input to include the child completion"
);
- let normal_request = response_requests
- .last()
- .cloned()
- .expect("last turn request missing");
- let compact_request = compact_mock.single_request();
- let normal_body = normal_request.body_json();
- let compact_body = compact_request.body_json();
+ assert!(
+ compact_request
+ .header("x-codex-beta-features")
+ .as_deref()
+ .is_some_and(|value| value
+ .split(',')
+ .any(|feature| feature == "remote_compaction_v2")),
+ "expected compact request to advertise the remote_compaction_v2 beta feature"
+ );
+ assert_eq!(compact_request.path(), "/v1/responses");
let compact_metadata: Value = serde_json::from_str(
&compact_request
.header("x-codex-turn-metadata")
- .expect("compaction turn metadata"),
- )?;
+ .expect("v2 compact request should include turn metadata"),
+ )
+ .expect("v2 compact turn metadata should be valid json");
assert_eq!(compact_metadata["turn_id"], compact_turn_id);
assert_eq!(compact_metadata["root_turn_id"], compact_turn_id);
- let expected_routing_hint = |body: &Value| {
- if !uses_codex_backend {
- return None;
- }
-
- let model = body["model"].as_str().expect("missing request model");
- match body.get("service_tier").and_then(Value::as_str) {
- Some(tier) => Some(format!("model={model};tier={tier}")),
- None => Some(format!("model={model}")),
- }
- };
assert_eq!(
- normal_request.header(X_CODEX_ROUTING_HINT_HEADER),
- expected_routing_hint(&normal_body)
+ compact_metadata["request_kind"].as_str(),
+ Some("compaction")
);
assert_eq!(
- compact_request.header(X_CODEX_ROUTING_HINT_HEADER),
- expected_routing_hint(&compact_body)
+ compact_metadata["window_id"].as_str(),
+ compact_request.header("x-codex-window-id").as_deref()
);
-
- let mut expected_compact_body_without_input = normal_body.clone();
- let expected_compact_object = expected_compact_body_without_input
- .as_object_mut()
- .expect("responses request body should be an object");
- for field in [
- "input",
- "client_metadata",
- "include",
- "store",
- "stream",
- "tool_choice",
- ] {
- expected_compact_object.remove(field);
- }
- if expected_service_tier.is_none() {
- expected_compact_object.remove("service_tier");
- }
- let mut compact_body_without_input = compact_body.clone();
- compact_body_without_input
- .as_object_mut()
- .expect("compact request body should be an object")
- .remove("input");
- let canonical_compact_body_without_input = canonical_json(&compact_body_without_input);
- let canonical_expected_compact_body_without_input =
- canonical_json(&expected_compact_body_without_input);
-
assert_eq!(
+ compact_request.body_json()["client_metadata"]["x-codex-window-id"].as_str(),
+ compact_metadata["window_id"].as_str()
+ );
+ assert_eq!(
+ compact_metadata["compaction"],
json!({
- "compact_body_without_input": canonical_compact_body_without_input,
- "expected_compact_body_without_input": canonical_expected_compact_body_without_input,
- "prompt_cache_key_matches_responses": compact_body["prompt_cache_key"] == normal_body["prompt_cache_key"],
- "prompt_cache_key_present": compact_body["prompt_cache_key"].is_string(),
- "service_tier": compact_body.get("service_tier").and_then(Value::as_str),
- }),
- json!({
- "compact_body_without_input": canonical_expected_compact_body_without_input,
- "expected_compact_body_without_input": canonical_expected_compact_body_without_input,
- "prompt_cache_key_matches_responses": true,
- "prompt_cache_key_present": true,
- "service_tier": expected_service_tier,
- }),
- "compact requests should carry the same shared request fields as /responses"
+ "trigger": "manual",
+ "reason": "user_requested",
+ "implementation": "responses_compaction_v2",
+ "phase": "standalone_turn",
+ "strategy": "memento",
+ })
);
-
- insta::assert_snapshot!(
- snapshot_name,
- context_snapshot::format_request_body_diff_snapshot(
- scenario,
- "Last Normal /responses Request",
- &normal_request,
- "Remote /responses/compact Request",
- &compact_request,
- &ContextSnapshotOptions::default().strip_response_item_ids(),
- )
+ let compact_body = compact_request.body_json().to_string();
+ assert!(
+ compact_body.contains("\"type\":\"compaction_trigger\""),
+ "expected v2 compaction request to include the compaction_trigger item"
+ );
+ assert!(
+ !compact_body.contains("ENCRYPTED_CONTEXT_COMPACTION_SUMMARY"),
+ "expected v2 compaction trigger item to omit encrypted_content"
);
- Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn remote_manual_compact_api_auth_omits_service_tier_and_reuses_prompt_cache_key()
--> Result<()> {
- skip_if_no_network!(Ok(()));
-
- assert_remote_manual_compact_request_parity(
- CodexAuth::from_api_key("dummy"),
- Some(ServiceTier::Fast),
- /*expected_service_tier*/ None,
- "remote_manual_compact_api_auth_prompt_cache_key_request_diff",
- "After five varied API-key-auth turns, remote manual compaction omits service_tier, reuses prompt_cache_key, and still omits responses-only fields.",
- )
- .await?;
-
- Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn remote_manual_compact_chatgpt_auth_reuses_service_tier_and_prompt_cache_key() -> Result<()>
-{
- skip_if_no_network!(Ok(()));
-
- assert_remote_manual_compact_request_parity(
- CodexAuth::create_dummy_chatgpt_auth_for_testing(),
- Some(ServiceTier::Fast),
- Some("priority"),
- "remote_manual_compact_chatgpt_auth_service_tier_prompt_cache_key_request_diff",
- "After five varied ChatGPT-auth turns, remote manual compaction reuses service_tier and prompt_cache_key while omitting responses-only fields.",
- )
- .await?;
-
- Ok(())
-}
-
-#[test_case(None; "default_trims_images")]
-#[test_case(Some(false); "disabled_preserves_images")]
-#[test_case(Some(true); "enabled_trims_images")]
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn remote_compact_v2_charges_retained_images_to_token_budget(
- image_budget_enabled: Option<bool>,
-) -> Result<()> {
- skip_if_no_network!(Ok(()));
-
- let harness = TestCodexHarness::with_auto_env_builder(
- test_codex()
- .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
- .with_config(move |config| {
- let _ = config.features.enable(Feature::RemoteCompactionV2);
- let _ = config.features.enable(Feature::UnifiedImageBudget);
- if let Some(enabled) = image_budget_enabled {
- let _ = config
- .features
- .set_enabled(Feature::CompactionImageBudget, enabled);
- }
- }),
- )
- .await?;
- let codex = &harness.test().codex;
- // Each original-detail image costs 10,000 estimated patch tokens.
- let image_inputs = (1..=8)
- .map(|number| {
- let image = image::ImageBuffer::from_pixel(
- /*width*/ 3200,
- /*height*/ 3200,
- image::Luma([number as u8]),
- );
- let mut bytes = std::io::Cursor::new(Vec::new());
- image.write_to(&mut bytes, image::ImageFormat::Png)?;
- Ok(UserInput::Image {
- image_url: format!(
- "data:image/png;base64,{}",
- BASE64_STANDARD.encode(bytes.get_ref())
- ),
- detail: Some(codex_protocol::models::ImageDetail::Original),
- })
- })
- .collect::<Result<Vec<_>>>()?;
- let mut input = image_inputs[..7].to_vec();
- input.push(UserInput::Text {
- text: "Compare these images".to_string(),
- text_elements: Vec::new(),
- });
- let initial_mock = mount_sse_once(
- harness.server(),
- sse(vec![
- responses::ev_assistant_message("initial", "done"),
- responses::ev_completed("initial"),
- ]),
- )
- .await;
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(input))
- .await?;
- wait_for_turn_complete(codex).await;
- let initial_request = initial_mock.single_request();
- let prepared_images = initial_request.message_input_image_urls("user");
- assert_eq!(prepared_images.len(), 7);
-
- for cycle in 1..=2 {
- let compact_mock = mount_sse_once(
- harness.server(),
- sse(vec![
- json!({
- "type": "response.output_item.done",
- "item": { "type": "compaction", "encrypted_content": "IMAGE_BUDGET_SUMMARY" },
- }),
- responses::ev_completed("compact-images"),
- ]),
- )
- .await;
- codex.submit(Op::Compact).await?;
- wait_for_turn_complete(codex).await;
- let compact_request = compact_mock.single_request();
- assert_eq!(compact_request.path(), "/v1/responses");
- assert_eq!(
- compact_request.inputs_of_type("compaction_trigger").len(),
- 1
- );
-
- let follow_up_mock = mount_sse_once(
- harness.server(),
- sse(vec![
- responses::ev_assistant_message("after", "done"),
- responses::ev_completed("after"),
- ]),
- )
- .await;
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "after compact".to_string(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_turn_complete(codex).await;
- let follow_up = follow_up_mock.single_request();
- assert_eq!(
- follow_up.inputs_of_type("compaction")[0]["encrypted_content"],
- "IMAGE_BUDGET_SUMMARY"
- );
- let dropped = if image_budget_enabled.unwrap_or(true) {
- cycle
- } else {
- 0
- };
- let mut expected_images = prepared_images[dropped..].to_vec();
- if cycle == 2 {
- let UserInput::Image { image_url, .. } = &image_inputs[7] else {
- unreachable!()
- };
- expected_images.push(image_url.clone());
- }
- assert_eq!(follow_up.message_input_image_urls("user"), expected_images);
- assert!(
- follow_up
- .message_input_texts("user")
- .iter()
- .any(|text| text == "Compare these images")
- );
-
- if cycle == 1 {
- let append_mock = mount_sse_once(
- harness.server(),
- sse(vec![
- responses::ev_assistant_message("append", "done"),
- responses::ev_completed("append"),
- ]),
- )
- .await;
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![image_inputs[7].clone()]))
- .await?;
- wait_for_turn_complete(codex).await;
- let _ = append_mock.single_request();
- }
- }
- Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn remote_compact_v2_reuses_compaction_trigger_for_followups() -> Result<()> {
- skip_if_no_network!(Ok(()));
-
- let harness = TestCodexHarness::with_builder(
- test_codex()
- .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
- .with_config(|config| {
- let _ = config.features.enable(Feature::RemoteCompactionV2);
- }),
- )
- .await?;
- let image_url = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR4nGNgYAAAAAMAASsJTYQAAAAASUVORK5CYII=";
- let user_notice = "<image_resize_notice>retained user image</image_resize_notice>";
- let tool_notice = "<image_resize_notice>discarded tool image</image_resize_notice>";
- let unlisted_notice = "<unlisted_notice>discarded developer notice</unlisted_notice>";
- let developer_message = |text| {
- json!({
- "type": "message",
- "role": "developer",
- "content": [{ "type": "input_text", "text": text }]
- })
- };
- let initial_history = [
- json!({
- "type": "message",
- "role": "user",
- "content": [
- { "type": "input_text", "text": "retained image source" },
- { "type": "input_image", "image_url": image_url }
- ]
- }),
- developer_message(user_notice),
- developer_message(unlisted_notice),
- json!({
- "type": "function_call",
- "name": "view_image",
- "arguments": "{}",
- "call_id": "image-call"
- }),
- json!({
- "type": "function_call_output",
- "call_id": "image-call",
- "output": [{ "type": "input_image", "image_url": image_url }]
- }),
- developer_message(tool_notice),
- ]
- .into_iter()
- .map(|item| {
- serde_json::from_value::<ResponseItem>(item)
- .map(|item| RolloutItem::ResponseItem(item.into()))
- })
- .collect::<serde_json::Result<Vec<_>>>()?;
- let codex = harness
- .test()
- .thread_manager
- .start_thread(StartThreadOptions {
- initial_history: InitialHistory::Forked(initial_history),
- ..StartThreadOptions::new(harness.test().config.clone())
- })
- .await?
- .thread;
-
- let responses_mock = responses::mount_sse_sequence(
- harness.server(),
- vec![
- responses::sse(vec![
- responses::ev_assistant_message("m1", "FIRST_REMOTE_REPLY"),
- responses::ev_completed("resp-1"),
- ]),
- responses::sse(vec![
- responses::ev_assistant_message("m-agent", "DELEGATED_TASK_REPLY"),
- responses::ev_completed("resp-agent"),
- ]),
- responses::sse(vec![
- responses::ev_assistant_message("m-descendant", "DESCENDANT_FOLLOWUP_REPLY"),
- responses::ev_completed("resp-descendant"),
- ]),
- responses::sse(vec![
- serde_json::json!({
- "type": "response.output_item.done",
- "item": {
- "type": "compaction",
- "encrypted_content": "ENCRYPTED_CONTEXT_COMPACTION_SUMMARY",
- }
- }),
- responses::ev_completed("resp-compact"),
- ]),
- responses::sse(vec![
- responses::ev_assistant_message("m2", "AFTER_COMPACT_REPLY"),
- responses::ev_completed("resp-2"),
- ]),
- ],
- )
- .await;
-
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "hello remote compact".into(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_turn_complete(&codex).await;
-
- codex
- .submit(Op::InterAgentCommunication {
- communication: InterAgentCommunication::new(
- AgentPath::root().join("child").expect("valid child path"),
- AgentPath::root(),
- Vec::new(),
- "Message Type: MESSAGE\nTask name: /root\nSender: /root/child\nPayload:\nchild progress"
- .to_string(),
- /*trigger_turn*/ false,
- ),
- start_options: Default::default(),
- })
- .await?;
- codex
- .submit(Op::InterAgentCommunication {
- communication: InterAgentCommunication::new(
- AgentPath::root().join("child").expect("valid child path"),
- AgentPath::root(),
- Vec::new(),
- "Message Type: FINAL_ANSWER\nTask name: /root\nSender: /root/child\nPayload:\nchild completion".to_string(),
- /*trigger_turn*/ false,
- ),
- start_options: Default::default(),
- })
- .await?;
- let delegated_task_ciphertext = format!("delegated compact task{}", "x".repeat(40_000));
- codex
- .submit(Op::InterAgentCommunication {
- communication: InterAgentCommunication::new_encrypted(
- AgentPath::root(),
- AgentPath::root().join("worker").expect("valid worker path"),
- Vec::new(),
- delegated_task_ciphertext.clone(),
- /*trigger_turn*/ true,
- ),
- start_options: Default::default(),
- })
- .await?;
- wait_for_turn_complete(&codex).await;
-
- let descendant_followup_ciphertext = "descendant follow-up task";
- let worker_path = AgentPath::root().join("worker").expect("valid worker path");
- codex
- .submit(Op::InterAgentCommunication {
- communication: InterAgentCommunication::new_encrypted(
- worker_path.join("child").expect("valid grandchild path"),
- worker_path,
- Vec::new(),
- descendant_followup_ciphertext.to_string(),
- /*trigger_turn*/ true,
- ),
- start_options: Default::default(),
- })
- .await?;
- wait_for_turn_complete(&codex).await;
-
- codex.submit(Op::Compact).await?;
- wait_for_turn_complete(&codex).await;
-
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "after compact".into(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_turn_complete(&codex).await;
-
- let response_requests = responses_mock.requests();
- let compact_request = &response_requests[3];
- let item_create_time = |request: &responses::ResponsesRequest, text: &str| {
- request
- .input()
- .into_iter()
- .find(|item| {
- item["content"].as_array().is_some_and(|content| {
- content.iter().any(|part| {
- part["text"].as_str() == Some(text)
- || part["encrypted_content"].as_str() == Some(text)
- })
- })
- })
- .and_then(|item| {
- item.pointer("/internal_chat_message_metadata_passthrough/create_time")
- .cloned()
- })
- .expect("matching message should include a creation timestamp")
- };
- let original_user_create_time = item_create_time(&response_requests[0], "hello remote compact");
- let delegated_task_create_time =
- item_create_time(&response_requests[1], &delegated_task_ciphertext);
- assert!(
- compact_request
- .inputs_of_type("agent_message")
- .iter()
- .any(|item| item["content"][1]["encrypted_content"].as_str()
- == Some(delegated_task_ciphertext.as_str())),
- "expected v2 compaction input to include the encrypted delegated task"
- );
- assert!(
- compact_request
- .inputs_of_type("agent_message")
- .iter()
- .any(|item| item["content"][1]["encrypted_content"].as_str()
- == Some(descendant_followup_ciphertext)),
- "expected v2 compaction input to include the descendant-authored follow-up task"
- );
- assert!(
- compact_request
- .inputs_of_type("agent_message")
- .iter()
- .any(|item| item.to_string().contains("child progress")),
- "expected v2 compaction input to include the child progress update"
- );
- assert!(
- compact_request
- .inputs_of_type("agent_message")
- .iter()
- .any(|item| item.to_string().contains("child completion")),
- "expected v2 compaction input to include the child completion"
- );
- assert!(
- compact_request
- .header("x-codex-beta-features")
- .as_deref()
- .is_some_and(|value| value
- .split(',')
- .any(|feature| feature == "remote_compaction_v2")),
- "expected compact request to advertise the remote_compaction_v2 beta feature"
- );
- assert_eq!(compact_request.path(), "/v1/responses");
- let compact_metadata: Value = serde_json::from_str(
- &compact_request
- .header("x-codex-turn-metadata")
- .expect("v2 compact request should include turn metadata"),
- )
- .expect("v2 compact turn metadata should be valid json");
- assert_eq!(
- compact_metadata["request_kind"].as_str(),
- Some("compaction")
- );
- assert_eq!(
- compact_metadata["window_id"].as_str(),
- compact_request.header("x-codex-window-id").as_deref()
- );
- assert_eq!(
- compact_request.body_json()["client_metadata"]["x-codex-window-id"].as_str(),
- compact_metadata["window_id"].as_str()
- );
- assert_eq!(
- compact_metadata["compaction"],
- json!({
- "trigger": "manual",
- "reason": "user_requested",
- "implementation": "responses_compaction_v2",
- "phase": "standalone_turn",
- "strategy": "memento",
- })
- );
- let compact_body = compact_request.body_json().to_string();
- assert!(
- compact_body.contains("\"type\":\"compaction_trigger\""),
- "expected v2 compaction request to include the compaction_trigger item"
- );
- assert!(
- !compact_body.contains("ENCRYPTED_CONTEXT_COMPACTION_SUMMARY"),
- "expected v2 compaction trigger item to omit encrypted_content"
- );
-
- let follow_up_request = response_requests.last().expect("follow-up request missing");
- assert_eq!(
- item_create_time(follow_up_request, "hello remote compact"),
- original_user_create_time
- );
- assert_eq!(
- item_create_time(follow_up_request, &delegated_task_ciphertext),
- delegated_task_create_time
- );
- assert!(
- item_create_time(follow_up_request, "after compact")
- .as_f64()
- .is_some_and(|create_time| create_time > 0.0)
- );
- assert!(
- follow_up_request
- .inputs_of_type("agent_message")
- .iter()
- .any(|item| item["content"][1]["encrypted_content"].as_str()
- == Some(delegated_task_ciphertext.as_str())),
- "expected v2 follow-up request to retain the encrypted delegated task"
- );
- assert!(
- follow_up_request
- .inputs_of_type("agent_message")
- .iter()
- .any(|item| item["content"][1]["encrypted_content"].as_str()
- == Some(descendant_followup_ciphertext)),
- "expected v2 follow-up request to retain the descendant-authored follow-up task"
- );
- assert!(
- follow_up_request
- .inputs_of_type("agent_message")
- .iter()
- .all(|item| !item.to_string().contains("child progress")),
- "expected v2 follow-up request to omit the child progress update"
- );
- assert!(
- follow_up_request
- .inputs_of_type("agent_message")
- .iter()
- .all(|item| !item.to_string().contains("child completion")),
- "expected v2 follow-up request to omit the child completion"
- );
- let follow_up_body = follow_up_request.body_json().to_string();
- assert!(
- follow_up_body.contains("\"type\":\"compaction\""),
- "expected follow-up request to preserve the compaction item"
- );
- assert!(
- follow_up_body.contains("ENCRYPTED_CONTEXT_COMPACTION_SUMMARY"),
- "expected follow-up request to include the compaction payload"
- );
- assert!(
- follow_up_body.contains("hello remote compact"),
- "expected v2 follow-up request to preserve retained original user messages"
- );
- assert!(
- follow_up_request.input().windows(2).any(|items| {
- items[0]["role"] == "user"
- && items[0]["content"][0]["text"] == "retained image source"
- && items[1]["role"] == "developer"
- && items[1]["content"][0]["text"] == user_notice
- }),
- "expected v2 compaction to retain the user image and its adjacent resize notice"
- );
- assert!(
- !follow_up_body.contains(unlisted_notice),
- "expected v2 compaction to drop unlisted developer notices"
- );
- assert!(
- !follow_up_body.contains(tool_notice),
- "expected v2 compaction to drop the resize notice with its tool output"
- );
-
- Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn remote_compact_v2_retries_failures_with_stream_retry_budget() -> Result<()> {
- skip_if_no_network!(Ok(()));
-
- let harness = TestCodexHarness::with_builder(
- test_codex()
- .with_history_mode(ThreadHistoryMode::Paginated)
- .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
- .with_config(|config| {
- let _ = config.features.enable(Feature::RemoteCompactionV2);
- config.model_provider.request_max_retries = Some(0);
- config.model_provider.stream_max_retries = Some(2);
- }),
- )
- .await?;
- let codex = harness.test().codex.clone();
-
- let responses_mock = responses::mount_response_sequence(
- harness.server(),
- vec![
- responses::sse_response(responses::sse(vec![
- responses::ev_assistant_message("m1", "FIRST_REMOTE_REPLY"),
- responses::ev_completed("resp-1"),
- ])),
- ResponseTemplate::new(500).set_body_string("first compact open failed"),
- responses::sse_response(responses::sse(vec![serde_json::json!({
- "type": "response.output_item.done",
- "item": {
- "type": "compaction",
- "encrypted_content": "FAILED_COMPACT_SUMMARY",
- }
- })])),
- responses::sse_response(responses::sse(vec![
- serde_json::json!({
- "type": "response.output_item.done",
- "item": {
- "type": "compaction",
- "encrypted_content": "RETRIED_COMPACT_SUMMARY",
- }
- }),
- responses::ev_completed("resp-compact-retry"),
- ])),
- responses::sse_response(responses::sse(vec![
- responses::ev_assistant_message("m2", "AFTER_COMPACT_REPLY"),
- responses::ev_completed("resp-2"),
- ])),
- ],
- )
- .await;
-
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "hello remote compact".into(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_turn_complete(&codex).await;
-
- codex.submit(Op::Compact).await?;
- wait_for_turn_complete(&codex).await;
-
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "after compact".into(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_turn_complete(&codex).await;
-
- let response_requests = responses_mock.requests();
- assert_eq!(
- 5,
- response_requests.len(),
- "expected initial turn, failed open, failed stream, compact retry, and follow-up turn"
- );
- for compact_request in &response_requests[1..=3] {
- assert_eq!("/v1/responses", compact_request.path());
- let compact_metadata: Value = serde_json::from_str(
- &compact_request
- .header("x-codex-turn-metadata")
- .expect("v2 compact request should include turn metadata"),
- )?;
- assert_eq!(compact_metadata["window_number"].as_u64(), Some(0));
- assert!(compact_metadata["context_window_id"].as_str().is_some());
- assert!(
- compact_request
- .body_json()
- .to_string()
- .contains("\"type\":\"compaction_trigger\""),
- "expected v2 compaction request to include the compaction_trigger item"
- );
- }
-
- let follow_up_request = response_requests.last().expect("follow-up request missing");
- let follow_up_body = follow_up_request.body_json().to_string();
- assert!(
- follow_up_body.contains("RETRIED_COMPACT_SUMMARY"),
- "expected follow-up request to include the retried compaction payload"
- );
- assert!(
- !follow_up_body.contains("FAILED_COMPACT_SUMMARY"),
- "expected failed compaction attempt output to be discarded"
- );
-
- Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn remote_compact_v2_accepts_additional_output_items_before_compaction() -> Result<()> {
- skip_if_no_network!(Ok(()));
-
- let harness = TestCodexHarness::with_builder(
- test_codex()
- .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
- .with_config(|config| {
- let _ = config.features.enable(Feature::RemoteCompactionV2);
- }),
- )
- .await?;
- let codex = harness.test().codex.clone();
-
- let responses_mock = responses::mount_sse_sequence(
- harness.server(),
- vec![
- responses::sse(vec![
- responses::ev_assistant_message("m1", "FIRST_REMOTE_REPLY"),
- responses::ev_completed("resp-1"),
- ]),
- responses::sse(vec![
- responses::ev_assistant_message("m-compact-noise", "IGNORED_COMPACT_REPLY"),
- serde_json::json!({
- "type": "response.output_item.done",
- "item": {
- "type": "compaction",
- "encrypted_content": "ENCRYPTED_CONTEXT_COMPACTION_SUMMARY",
- }
- }),
- responses::ev_completed("resp-compact"),
- ]),
- responses::sse(vec![
- responses::ev_assistant_message("m2", "AFTER_COMPACT_REPLY"),
- responses::ev_completed("resp-2"),
- ]),
- ],
- )
- .await;
-
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "hello remote compact".into(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_turn_complete(&codex).await;
-
- codex.submit(Op::Compact).await?;
- wait_for_turn_complete(&codex).await;
-
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "after compact".into(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_turn_complete(&codex).await;
-
- let response_requests = responses_mock.requests();
- let follow_up_request = response_requests.last().expect("follow-up request missing");
- let follow_up_body = follow_up_request.body_json().to_string();
- assert!(
- follow_up_body.contains("\"type\":\"compaction\""),
- "expected follow-up request to preserve the compaction item"
- );
- assert!(
- follow_up_body.contains("ENCRYPTED_CONTEXT_COMPACTION_SUMMARY"),
- "expected follow-up request to include the compaction payload"
- );
- assert!(
- !follow_up_body.contains("IGNORED_COMPACT_REPLY"),
- "expected follow-up request to ignore unrelated output items from the compaction stream"
- );
-
- Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn remote_compact_filters_deferred_dynamic_tools() -> Result<()> {
- skip_if_no_network!(Ok(()));
-
- let server = responses::start_mock_server().await;
- let mut builder = test_codex().with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing());
- let mut test = builder.build(&server).await?;
- let hidden_tool = "hidden_dynamic_tool";
- let visible_tool = "visible_dynamic_tool";
- let input_schema = json!({
- "type": "object",
- "properties": {},
- "additionalProperties": false,
- });
- let dynamic_tools = vec![DynamicToolSpec::Namespace(DynamicToolNamespaceSpec {
- name: "codex_app".to_string(),
- description: "Codex app tools.".to_string(),
- tools: vec![
- DynamicToolNamespaceTool::Function(DynamicToolFunctionSpec {
- name: hidden_tool.to_string(),
- description: "Hidden until discovered.".to_string(),
- input_schema: input_schema.clone(),
- defer_loading: true,
- }),
- DynamicToolNamespaceTool::Function(DynamicToolFunctionSpec {
- name: visible_tool.to_string(),
- description: "Visible immediately.".to_string(),
- input_schema,
- defer_loading: false,
- }),
- ],
- })];
- let new_thread = test
- .thread_manager
- .start_thread(StartThreadOptions {
- dynamic_tools,
- ..StartThreadOptions::new(test.config.clone())
- })
- .await?;
- test.codex = new_thread.thread;
- test.session_configured = new_thread.session_configured;
- let codex = test.codex.clone();
-
- let responses_mock = mount_sse_once(
- &server,
- sse(vec![
- responses::ev_assistant_message("m1", "FIRST_REMOTE_REPLY"),
- responses::ev_completed("resp-1"),
- ]),
- )
- .await;
- let compact_mock = responses::mount_compact_json_once(
- &server,
- serde_json::json!({
- "output": compacted_summary_only_output("compact summary"),
- }),
- )
- .await;
-
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "hello remote compact".into(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_turn_complete(&codex).await;
-
- codex.submit(Op::Compact).await?;
- wait_for_turn_complete(&codex).await;
-
- let first_response_body = responses_mock.single_request().body_json();
- let compact_body = compact_mock.single_request().body_json();
- assert_eq!(
- compact_body["tools"], first_response_body["tools"],
- "compact requests should send the same model-visible tools payload as /v1/responses"
- );
- assert_tools_payload_does_not_defer(&first_response_body);
- assert_tools_payload_does_not_defer(&compact_body);
- assert_eq!(
- namespace_child_tool_names(&first_response_body, "codex_app"),
- vec![visible_tool.to_string()]
- );
- assert_eq!(
- namespace_child_tool_names(&compact_body, "codex_app"),
- vec![visible_tool.to_string()]
- );
-
- Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn remote_compact_does_not_charge_inline_audio_payload_as_text() -> Result<()> {
- skip_if_no_network!(Ok(()));
-
- let server = responses::start_mock_server().await;
- let call_id = "audio-call";
- let tool_name = "recording";
- let audio_url = pcm_wav_data_url(/*sample_count*/ 300_000);
- let responses_mock = responses::mount_sse_sequence(
- &server,
- vec![
- sse(vec![
- responses::ev_response_created("resp-1"),
- responses::ev_function_call_with_namespace(call_id, "codex_app", tool_name, "{}"),
- responses::ev_completed_with_tokens("resp-1", /*total_tokens*/ 100),
- ]),
- sse(vec![
- responses::ev_response_created("resp-2"),
- responses::ev_assistant_message("msg-1", "done"),
- responses::ev_completed_with_tokens("resp-2", /*total_tokens*/ 200),
- ]),
- ],
- )
- .await;
- let compact_mock = responses::mount_compact_json_once(
- &server,
- json!({ "output": compacted_summary_only_output("compact summary") }),
- )
- .await;
-
- let mut builder = test_codex()
- .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
- .with_model_info_override("gpt-5.5", |model_info| {
- model_info.input_modalities.push(InputModality::Audio);
- })
- .with_config(|config| {
- config.model_context_window = Some(50_000);
- });
- let mut test = builder.build(&server).await?;
- let dynamic_tool = DynamicToolSpec::Namespace(DynamicToolNamespaceSpec {
- name: "codex_app".to_string(),
- description: "Audio tools.".to_string(),
- tools: vec![DynamicToolNamespaceTool::Function(
- DynamicToolFunctionSpec {
- name: tool_name.to_string(),
- description: "Returns a recording.".to_string(),
- input_schema: json!({
- "type": "object",
- "properties": {},
- "additionalProperties": false,
- }),
- defer_loading: false,
- },
- )],
- });
- let new_thread = test
- .thread_manager
- .start_thread(StartThreadOptions {
- dynamic_tools: vec![dynamic_tool],
- ..StartThreadOptions::new(test.config.clone())
- })
- .await?;
- test.codex = new_thread.thread;
- test.session_configured = new_thread.session_configured;
-
- test.codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "Return a recording".to_string(),
- text_elements: Vec::new(),
- }]))
- .await?;
- let EventMsg::DynamicToolCallRequest(request) = wait_for_event(&test.codex, |event| {
- matches!(event, EventMsg::DynamicToolCallRequest(_))
- })
- .await
- else {
- unreachable!("event guard guarantees DynamicToolCallRequest");
- };
- test.codex
- .submit(Op::DynamicToolResponse {
- id: request.call_id,
- response: DynamicToolResponse {
- content_items: vec![DynamicToolCallOutputContentItem::InputAudio {
- audio_url: audio_url.clone(),
- }],
- success: true,
- },
- })
- .await?;
- wait_for_turn_complete(&test.codex).await;
-
- test.codex.submit(Op::Compact).await?;
- wait_for_turn_complete(&test.codex).await;
-
- assert_eq!(responses_mock.requests().len(), 2);
- let output = compact_mock
- .single_request()
- .function_call_output(call_id)
- .get("output")
- .cloned()
- .expect("compact request should retain the dynamic tool output");
- assert_eq!(
- serde_json::from_value::<FunctionCallOutputPayload>(output)?,
- FunctionCallOutputPayload {
- body: FunctionCallOutputBody::ContentItems(vec![
- FunctionCallOutputContentItem::InputAudio { audio_url },
- ]),
- success: None,
- }
- );
-
- Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn remote_compact_runs_automatically() -> Result<()> {
- skip_if_no_network!(Ok(()));
-
- let harness = TestCodexHarness::with_builder(
- test_codex()
- .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
- .with_pre_build_hook(allow_echo_commands),
- )
- .await?;
- let codex = harness.test().codex.clone();
- let session_id = harness.test().session_configured.session_id.to_string();
- let thread_id = harness.test().session_configured.thread_id.to_string();
-
- let initial_request = mount_sse_once(
- harness.server(),
- sse(vec![
- responses::ev_exec_command_call("m1", "echo 'hi'"),
- responses::ev_completed_with_tokens("resp-1", /*total_tokens*/ 100000000), // over token limit
- ]),
- )
- .await;
- let responses_mock = mount_sse_once(
- harness.server(),
- responses::sse(vec![
- responses::ev_assistant_message("m2", "AFTER_COMPACT_REPLY"),
- responses::ev_completed("resp-2"),
- ]),
- )
- .await;
-
- let compact_mock = responses::mount_compact_user_history_with_summary_once(
- harness.server(),
- "REMOTE_COMPACTED_SUMMARY",
- )
- .await;
-
- codex
- .start_or_steer_turn(unrestricted_user_turn(vec![UserInput::Text {
- text: "hello remote compact".into(),
- text_elements: Vec::new(),
- }]))
- .await?;
-
- let message = wait_for_event_match(&codex, |event| match event {
- EventMsg::ContextCompacted(_) => Some(true),
- _ => None,
- })
- .await;
- wait_for_event(&codex, |event| matches!(event, EventMsg::TurnComplete(_))).await;
- assert!(message);
- assert_eq!(compact_mock.requests().len(), 1);
- assert_eq!(
- compact_mock
- .single_request()
- .header("session-id")
- .as_deref(),
- Some(session_id.as_str())
- );
- assert_eq!(
- compact_mock.single_request().header("thread-id").as_deref(),
- Some(thread_id.as_str())
- );
- let compact_metadata: Value = serde_json::from_str(
- &compact_mock
- .single_request()
- .header("x-codex-turn-metadata")
- .expect("auto remote compact request should include turn metadata"),
- )
- .expect("auto remote compact turn metadata should be valid json");
- assert_eq!(
- compact_metadata["request_kind"].as_str(),
- Some("compaction")
- );
- assert_eq!(
- compact_metadata["compaction"],
- json!({
- "trigger": "auto",
- "reason": "context_limit",
- "implementation": "responses_compact",
- "phase": "mid_turn",
- "strategy": "memento",
- })
- );
- let initial_metadata: Value = serde_json::from_str(
- &initial_request
- .single_request()
- .header("x-codex-turn-metadata")
- .expect("initial request should include turn metadata"),
- )
- .expect("initial turn metadata should be valid json");
- assert_eq!(
- initial_metadata["turn_id"], compact_metadata["turn_id"],
- "automatic mid-turn compaction should keep the current turn id"
- );
- assert_eq!(
- initial_metadata["window_id"], compact_metadata["window_id"],
- "automatic mid-turn compaction summarizes the current context window"
- );
- let follow_up_request = responses_mock.single_request();
- let follow_up_metadata: Value = serde_json::from_str(
- &follow_up_request
- .header("x-codex-turn-metadata")
- .expect("post-compaction continuation should include turn metadata"),
- )
- .expect("post-compaction turn metadata should be valid json");
- assert_eq!(
- follow_up_metadata["request_kind"].as_str(),
- Some("turn"),
- "post-compaction continuation should be a regular request"
- );
- assert!(follow_up_metadata.get("compaction").is_none());
- assert_eq!(
- follow_up_metadata["turn_id"], compact_metadata["turn_id"],
- "automatic mid-turn continuation should keep the current turn id"
- );
- assert_ne!(
- follow_up_metadata["window_id"], compact_metadata["window_id"],
- "post-compaction continuation should use the next context window"
- );
- let follow_up_body = follow_up_request.body_json().to_string();
- assert!(follow_up_body.contains("REMOTE_COMPACTED_SUMMARY"));
-
- Ok(())
-}
-
-#[cfg_attr(target_os = "windows", ignore)]
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn remote_compact_trims_function_call_history_to_fit_context_window() -> Result<()> {
- skip_if_no_network!(Ok(()));
-
- let first_user_message = "turn with retained shell call";
- let second_user_message = "turn with trimmed shell call";
- let retained_call_id = "retained-call";
- let trimmed_call_id = "trimmed-call";
- let retained_command = "echo retained-shell-output";
- let trimmed_command = "yes x | head -n 3000";
-
- let harness = TestCodexHarness::with_builder(
- test_codex()
- .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
- .with_config(|config| {
- config.model_context_window = Some(2_000);
- config.model_auto_compact_token_limit = Some(200_000);
- }),
- )
- .await?;
- let codex = harness.test().codex.clone();
-
- responses::mount_sse_sequence(
- harness.server(),
- vec![
- sse(vec![
- responses::ev_exec_command_call(retained_call_id, retained_command),
- responses::ev_completed("retained-call-response"),
- ]),
- sse(vec![
- responses::ev_assistant_message("retained-assistant", "retained complete"),
- responses::ev_completed("retained-final-response"),
- ]),
- sse(vec![
- responses::ev_exec_command_call(trimmed_call_id, trimmed_command),
- responses::ev_completed("trimmed-call-response"),
- ]),
- ],
- )
- .await;
-
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: first_user_message.into(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_event(&codex, |event| matches!(event, EventMsg::TurnComplete(_))).await;
-
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: second_user_message.into(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_event(&codex, |event| matches!(event, EventMsg::TurnComplete(_))).await;
-
- let compact_mock = responses::mount_compact_user_history_with_summary_once(
- harness.server(),
- "REMOTE_COMPACT_SUMMARY",
- )
- .await;
-
- codex.submit(Op::Compact).await?;
- wait_for_event(&codex, |event| matches!(event, EventMsg::TurnComplete(_))).await;
-
- let compact_request = compact_mock.single_request();
- let user_messages = compact_request.message_input_texts("user");
- assert!(
- user_messages
- .iter()
- .any(|message| message == first_user_message),
- "expected compact request to retain earlier user history"
- );
- assert!(
- user_messages
- .iter()
- .any(|message| message == second_user_message),
- "expected compact request to retain the user boundary message"
- );
-
- assert!(
- compact_request.has_function_call(retained_call_id)
- && compact_request
- .function_call_output_text(retained_call_id)
- .is_some(),
- "expected compact request to keep the older function call/result pair"
- );
- assert!(
- compact_request.has_function_call(trimmed_call_id),
- "expected compact request to retain the trailing function call"
- );
- assert_eq!(
- compact_request.function_call_output_text(trimmed_call_id),
- Some(CONTEXT_WINDOW_TRUNCATED_OUTPUT_MESSAGE.to_string()),
- "expected compact request to rewrite the trailing function call output past the boundary"
- );
-
- assert_eq!(
- compact_request.inputs_of_type("function_call").len(),
- 2,
- "expected both function calls after rewriting the trailing output"
- );
- assert_eq!(
- compact_request.inputs_of_type("function_call_output").len(),
- 2,
- "expected both function call outputs after rewriting the trailing output"
- );
-
- Ok(())
-}
-
-#[cfg_attr(target_os = "windows", ignore)]
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn remote_compact_rewrites_multiple_trailing_function_call_outputs() -> Result<()> {
- skip_if_no_network!(Ok(()));
-
- let first_user_message = "turn with retained shell call";
- let second_user_message = "turn with parallel shell calls";
- let retained_call_id = "retained-call";
- let first_trimmed_call_id = "first-trimmed-call";
- let second_trimmed_call_id = "second-trimmed-call";
- let retained_command = "echo retained-shell-output";
- let first_trimmed_command = "yes x | head -n 3000";
- let second_trimmed_command = "yes y | head -n 3000";
-
- let harness = TestCodexHarness::with_builder(
- test_codex()
- .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
- .with_config(|config| {
- config.model_context_window = Some(2_000);
- config.model_auto_compact_token_limit = Some(200_000);
- }),
- )
- .await?;
- let codex = harness.test().codex.clone();
-
- responses::mount_sse_sequence(
- harness.server(),
- vec![
- sse(vec![
- responses::ev_exec_command_call(retained_call_id, retained_command),
- responses::ev_completed("retained-call-response"),
- ]),
- sse(vec![
- responses::ev_assistant_message("retained-assistant", "retained complete"),
- responses::ev_completed("retained-final-response"),
- ]),
- sse(vec![
- responses::ev_exec_command_call(first_trimmed_call_id, first_trimmed_command),
- responses::ev_exec_command_call(second_trimmed_call_id, second_trimmed_command),
- responses::ev_completed("parallel-call-response"),
- ]),
- ],
- )
- .await;
-
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: first_user_message.into(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_event(&codex, |event| matches!(event, EventMsg::TurnComplete(_))).await;
-
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: second_user_message.into(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_event(&codex, |event| matches!(event, EventMsg::TurnComplete(_))).await;
-
- let compact_mock = responses::mount_compact_user_history_with_summary_once(
- harness.server(),
- "REMOTE_COMPACT_SUMMARY",
- )
- .await;
-
- codex.submit(Op::Compact).await?;
- wait_for_event(&codex, |event| matches!(event, EventMsg::TurnComplete(_))).await;
-
- let compact_request = compact_mock.single_request();
- assert!(
- compact_request.has_function_call(retained_call_id)
- && compact_request
- .function_call_output_text(retained_call_id)
- .is_some(),
- "expected compact request to keep the older function call/result pair"
- );
- assert!(
- compact_request.has_function_call(first_trimmed_call_id)
- && compact_request.has_function_call(second_trimmed_call_id),
- "expected compact request to retain both trailing parallel function calls"
- );
- assert_eq!(
- compact_request.function_call_output_text(first_trimmed_call_id),
- Some(CONTEXT_WINDOW_TRUNCATED_OUTPUT_MESSAGE.to_string()),
- "expected compact request to rewrite the first trailing function call output"
- );
- assert_eq!(
- compact_request.function_call_output_text(second_trimmed_call_id),
- Some(CONTEXT_WINDOW_TRUNCATED_OUTPUT_MESSAGE.to_string()),
- "expected compact request to rewrite the second trailing function call output"
- );
-
- assert_eq!(
- compact_request.inputs_of_type("function_call").len(),
- 3,
- "expected all function calls after rewriting trailing outputs"
- );
- assert_eq!(
- compact_request.inputs_of_type("function_call_output").len(),
- 3,
- "expected all function call outputs after rewriting trailing outputs"
- );
-
- Ok(())
-}
-
-#[cfg_attr(target_os = "windows", ignore)]
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn auto_remote_compact_trims_function_call_history_to_fit_context_window() -> Result<()> {
- skip_if_no_network!(Ok(()));
-
- let first_user_message = "turn with retained shell call";
- let second_user_message = "turn with trimmed shell call";
- let retained_call_id = "retained-call";
- let trimmed_call_id = "trimmed-call";
- let retained_command = "echo retained-shell-output";
- let trimmed_command = "yes x | head -n 3000";
- let harness = TestCodexHarness::with_builder(
- test_codex()
- .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
- .with_config(|config| {
- config.model_context_window = Some(2_000);
- config.model_auto_compact_token_limit = Some(200_000);
- }),
- )
- .await?;
- let codex = harness.test().codex.clone();
-
- responses::mount_sse_sequence(
- harness.server(),
- vec![
- sse(vec![
- responses::ev_exec_command_call(retained_call_id, retained_command),
- responses::ev_completed_with_tokens(
- "retained-call-response",
- /*total_tokens*/ 100,
- ),
- ]),
- sse(vec![
- responses::ev_assistant_message("retained-assistant", "retained complete"),
- responses::ev_completed("retained-final-response"),
- ]),
- sse(vec![
- responses::ev_exec_command_call(trimmed_call_id, trimmed_command),
- responses::ev_completed_with_tokens(
- "trimmed-call-response",
- /*total_tokens*/ 100,
- ),
- ]),
- sse(vec![responses::ev_completed_with_tokens(
- "trimmed-final-response",
- /*total_tokens*/ 500_000,
- )]),
- ],
- )
- .await;
-
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: first_user_message.into(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_event(&codex, |event| matches!(event, EventMsg::TurnComplete(_))).await;
-
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: second_user_message.into(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_event(&codex, |event| matches!(event, EventMsg::TurnComplete(_))).await;
-
- let compact_mock = responses::mount_compact_user_history_with_summary_once(
- harness.server(),
- "REMOTE_AUTO_COMPACT_SUMMARY",
- )
- .await;
-
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "turn that triggers auto compact".into(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_event(&codex, |event| matches!(event, EventMsg::TurnComplete(_))).await;
- assert_eq!(
- compact_mock.requests().len(),
- 1,
- "expected exactly one remote compact request"
- );
-
- let compact_request = compact_mock.single_request();
- let user_messages = compact_request.message_input_texts("user");
- assert!(
- user_messages
- .iter()
- .any(|message| message == first_user_message),
- "expected compact request to retain earlier user history"
- );
- assert!(
- user_messages
- .iter()
- .any(|message| message == second_user_message),
- "expected compact request to retain the user boundary message"
- );
-
- assert!(
- compact_request.has_function_call(retained_call_id)
- && compact_request
- .function_call_output_text(retained_call_id)
- .is_some(),
- "expected compact request to keep the older function call/result pair"
- );
- assert!(
- compact_request.has_function_call(trimmed_call_id),
- "expected compact request to retain the trailing function call"
- );
- assert_eq!(
- compact_request.function_call_output_text(trimmed_call_id),
- Some(CONTEXT_WINDOW_TRUNCATED_OUTPUT_MESSAGE.to_string()),
- "expected compact request to rewrite the trailing function call output past the boundary"
- );
-
- assert_eq!(
- compact_request.inputs_of_type("function_call").len(),
- 2,
- "expected both function calls after rewriting the trailing output"
- );
- assert_eq!(
- compact_request.inputs_of_type("function_call_output").len(),
- 2,
- "expected both function call outputs after rewriting the trailing output"
- );
-
- Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn remote_compact_trims_tool_search_output_to_empty_tools_array() -> Result<()> {
- skip_if_no_network!(Ok(()));
-
- let server = responses::start_mock_server().await;
- let search_call_id = "tool-search-1";
- let tool_name = "oversized_dynamic_tool";
- let tool_description = format!(
- "Oversized deferred tool for remote compaction. {}",
- "x".repeat(20_000)
- );
- let _responses_mock = mount_sse_once(
- &server,
- sse(vec![
- responses::ev_response_created("resp-1"),
- responses::ev_tool_search_call(
- search_call_id,
- &json!({
- "query": "oversized deferred tool",
- "limit": 8,
- }),
- ),
- responses::ev_completed("resp-1"),
- ]),
- )
- .await;
-
- let input_schema = json!({
- "type": "object",
- "properties": {
- "mode": { "type": "string" },
- },
- "required": ["mode"],
- "additionalProperties": false,
- });
- let dynamic_tool = DynamicToolSpec::Namespace(DynamicToolNamespaceSpec {
- name: "codex_app".to_string(),
- description: "Codex app tools.".to_string(),
- tools: vec![DynamicToolNamespaceTool::Function(
- DynamicToolFunctionSpec {
- name: tool_name.to_string(),
- description: tool_description,
- input_schema,
- defer_loading: true,
- },
- )],
- });
-
- let mut builder = test_codex()
- .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
- .with_config(|config| {
- configure_search_capable_model(config);
- config.model_context_window = Some(2_000);
- });
- let mut test = builder.build(&server).await?;
- let new_thread = test
- .thread_manager
- .start_thread(StartThreadOptions {
- dynamic_tools: vec![dynamic_tool],
- ..StartThreadOptions::new(test.config.clone())
- })
- .await?;
- test.codex = new_thread.thread;
- test.session_configured = new_thread.session_configured;
- let codex = test.codex.clone();
-
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "Find the oversized deferred tool".to_string(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_turn_complete(&codex).await;
-
- let compact_mock =
- responses::mount_compact_user_history_with_summary_once(&server, "REMOTE_COMPACT_SUMMARY")
- .await;
-
- codex.submit(Op::Compact).await?;
- wait_for_turn_complete(&codex).await;
-
- let compact_request = compact_mock.single_request();
- let compact_tools = compact_request
- .tool_search_output(search_call_id)
- .get("tools")
- .and_then(Value::as_array)
- .cloned()
- .unwrap_or_default();
- assert!(
- compact_request
- .inputs_of_type("tool_search_output")
- .iter()
- .any(|item| item.get("call_id").and_then(Value::as_str) == Some(search_call_id)),
- "expected compact request to retain the tool_search_output item"
- );
- assert!(
- compact_tools.is_empty(),
- "expected compact request to rewrite trailing tool_search output to an empty tools array"
- );
-
- Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn auto_remote_compact_failure_stops_agent_loop() -> Result<()> {
- skip_if_no_network!(Ok(()));
-
- let harness = TestCodexHarness::with_builder(
- test_codex()
- .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
- .with_config(|config| {
- config.model_auto_compact_token_limit = Some(120);
- }),
- )
- .await?;
- let codex = harness.test().codex.clone();
-
- mount_sse_once(
- harness.server(),
- sse(vec![
- responses::ev_assistant_message("initial-assistant", "initial turn complete"),
- responses::ev_completed_with_tokens("initial-response", /*total_tokens*/ 500_000),
- ]),
- )
- .await;
-
- let first_compact_mock = responses::mount_compact_json_once(
- harness.server(),
- serde_json::json!({ "output": "invalid compact payload shape" }),
- )
- .await;
- let post_compact_turn_mock = mount_sse_once(
- harness.server(),
- sse(vec![
- responses::ev_assistant_message("post-compact-assistant", "should not run"),
- responses::ev_completed("post-compact-response"),
- ]),
- )
- .await;
-
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "turn that exceeds token threshold".into(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_event(&codex, |event| matches!(event, EventMsg::TurnComplete(_))).await;
-
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "turn that triggers auto compact".into(),
- text_elements: Vec::new(),
- }]))
- .await?;
-
- let error_message = wait_for_event_match(&codex, |event| match event {
- EventMsg::Error(err) => Some(err.message.clone()),
- _ => None,
- })
- .await;
- wait_for_event(&codex, |event| matches!(event, EventMsg::TurnComplete(_))).await;
-
- assert!(
- error_message.contains("Error running remote compact task"),
- "expected remote compact task error prefix, got {error_message}"
- );
- assert_eq!(
- first_compact_mock.requests().len(),
- 1,
- "expected first remote compact attempt with incoming items"
- );
- assert!(
- post_compact_turn_mock.requests().is_empty(),
- "expected agent loop to stop after compaction failure"
- );
-
- insta::assert_snapshot!(
- "remote_pre_turn_compaction_failure_shapes",
- format_labeled_requests_snapshot(
- "Remote pre-turn auto-compaction parse failure: compaction request excludes the incoming user message and the turn stops.",
- &[(
- "Remote Compaction Request (Incoming User Excluded)",
- &first_compact_mock.single_request()
- ),]
- )
- );
-
- Ok(())
-}
-
-#[cfg_attr(target_os = "windows", ignore)]
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn remote_compact_trim_estimate_uses_session_base_instructions() -> Result<()> {
- skip_if_no_network!(Ok(()));
-
- let first_user_message = "turn with baseline shell call";
- let second_user_message = "turn with trailing shell call";
- let baseline_retained_call_id = "baseline-retained-call";
- let baseline_trailing_call_id = "baseline-trailing-call";
- let override_retained_call_id = "override-retained-call";
- let override_trailing_call_id = "override-trailing-call";
- let retained_command = "printf retained-shell-output";
- let trailing_command = "printf '%020000d' 0";
-
- let baseline_harness = TestCodexHarness::with_builder(
- test_codex()
- .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
- .with_config(|config| {
- config.model_context_window = Some(200_000);
- }),
- )
- .await?;
- let baseline_codex = baseline_harness.test().codex.clone();
-
- responses::mount_sse_sequence(
- baseline_harness.server(),
- vec![
- sse(vec![
- responses::ev_exec_command_call(baseline_retained_call_id, retained_command),
- responses::ev_completed("baseline-retained-call-response"),
- ]),
- sse(vec![
- responses::ev_assistant_message("baseline-retained-assistant", "retained complete"),
- responses::ev_completed("baseline-retained-final-response"),
- ]),
- sse(vec![
- responses::ev_exec_command_call(baseline_trailing_call_id, trailing_command),
- responses::ev_completed("baseline-trailing-call-response"),
- ]),
- sse(vec![responses::ev_completed(
- "baseline-trailing-final-response",
- )]),
- ],
- )
- .await;
-
- baseline_codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: first_user_message.into(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_event(&baseline_codex, |event| {
- matches!(event, EventMsg::TurnComplete(_))
- })
- .await;
-
- baseline_codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: second_user_message.into(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_event(&baseline_codex, |event| {
- matches!(event, EventMsg::TurnComplete(_))
- })
- .await;
-
- let baseline_compact_mock = responses::mount_compact_user_history_with_summary_once(
- baseline_harness.server(),
- "REMOTE_BASELINE_SUMMARY",
- )
- .await;
-
- baseline_codex.submit(Op::Compact).await?;
- wait_for_event(&baseline_codex, |event| {
- matches!(event, EventMsg::TurnComplete(_))
- })
- .await;
-
- let baseline_compact_request = baseline_compact_mock.single_request();
- assert!(
- baseline_compact_request.has_function_call(baseline_retained_call_id),
- "expected baseline compact request to retain older function call history"
- );
- assert!(
- baseline_compact_request.has_function_call(baseline_trailing_call_id),
- "expected baseline compact request to retain trailing function call history"
- );
-
- let baseline_input_tokens = estimate_compact_input_tokens(&baseline_compact_request);
- let baseline_payload_tokens = estimate_compact_payload_tokens(&baseline_compact_request);
-
- let override_base_instructions = format!(
- "{}\nREMOTE_BASE_INSTRUCTIONS_OVERRIDE {}",
- baseline_compact_request.instructions_text(),
- "x".repeat(8_000)
- );
- let override_context_window = baseline_payload_tokens.saturating_add(500);
- let pretrim_override_estimate =
- baseline_input_tokens.saturating_add(approx_token_count(&override_base_instructions));
- assert!(
- pretrim_override_estimate > override_context_window,
- "expected override instructions to push pre-trim estimate past the context window"
- );
-
- let override_harness = TestCodexHarness::with_builder(
- test_codex()
- .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
- .with_config({
- let override_base_instructions = override_base_instructions.clone();
- move |config| {
- config.model_context_window = Some(override_context_window);
- config.base_instructions = Some(override_base_instructions);
- }
- }),
- )
- .await?;
- let override_codex = override_harness.test().codex.clone();
-
- responses::mount_sse_sequence(
- override_harness.server(),
- vec![
- sse(vec![
- responses::ev_exec_command_call(override_retained_call_id, retained_command),
- responses::ev_completed("override-retained-call-response"),
- ]),
- sse(vec![
- responses::ev_assistant_message("override-retained-assistant", "retained complete"),
- responses::ev_completed("override-retained-final-response"),
- ]),
- sse(vec![
- responses::ev_exec_command_call(override_trailing_call_id, trailing_command),
- responses::ev_completed("override-trailing-call-response"),
- ]),
- sse(vec![responses::ev_completed(
- "override-trailing-final-response",
- )]),
- ],
- )
- .await;
-
- override_codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: first_user_message.into(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_event(&override_codex, |event| {
- matches!(event, EventMsg::TurnComplete(_))
- })
- .await;
-
- override_codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: second_user_message.into(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_event(&override_codex, |event| {
- matches!(event, EventMsg::TurnComplete(_))
- })
- .await;
-
- let override_compact_mock = responses::mount_compact_user_history_with_summary_once(
- override_harness.server(),
- "REMOTE_OVERRIDE_SUMMARY",
- )
- .await;
-
- override_codex.submit(Op::Compact).await?;
- wait_for_event(&override_codex, |event| {
- matches!(event, EventMsg::TurnComplete(_))
- })
- .await;
-
- let override_compact_request = override_compact_mock.single_request();
- assert_eq!(
- override_compact_request.instructions_text(),
- override_base_instructions
- );
- assert!(
- override_compact_request.has_function_call(override_retained_call_id),
- "expected remote compact request to preserve older function call history"
- );
- assert!(
- override_compact_request.has_function_call(override_trailing_call_id),
- "expected remote compact request to preserve trailing function call history with override instructions"
- );
- assert_eq!(
- override_compact_request.function_call_output_text(override_trailing_call_id),
- Some(CONTEXT_WINDOW_TRUNCATED_OUTPUT_MESSAGE.to_string()),
- "expected remote compact request to rewrite trailing function call output with override instructions"
- );
-
- Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn remote_manual_compact_emits_context_compaction_items() -> Result<()> {
- skip_if_no_network!(Ok(()));
-
- let harness = TestCodexHarness::with_builder(
- test_codex().with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing()),
- )
- .await?;
- let codex = harness.test().codex.clone();
-
- mount_sse_once(
- harness.server(),
- sse(vec![
- responses::ev_assistant_message("m1", "REMOTE_REPLY"),
- responses::ev_completed("resp-1"),
- ]),
- )
- .await;
-
- let compact_mock = responses::mount_compact_user_history_with_summary_once(
- harness.server(),
- "REMOTE_COMPACTED_SUMMARY",
- )
- .await;
-
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "manual remote compact".into(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_event(&codex, |event| matches!(event, EventMsg::TurnComplete(_))).await;
-
- codex.submit(Op::Compact).await?;
-
- let mut started_item = None;
- let mut completed_item = None;
- let mut legacy_event = false;
- let mut saw_turn_complete = false;
-
- while !saw_turn_complete || started_item.is_none() || completed_item.is_none() || !legacy_event
- {
- let event = codex.next_event().await.unwrap();
- match event.msg {
- EventMsg::ItemStarted(ItemStartedEvent {
- item: TurnItem::ContextCompaction(item),
- ..
- }) => {
- started_item = Some(item);
- }
- EventMsg::ItemCompleted(ItemCompletedEvent {
- item: TurnItem::ContextCompaction(item),
- ..
- }) => {
- completed_item = Some(item);
- }
- EventMsg::ContextCompacted(_) => {
- legacy_event = true;
- }
- EventMsg::TurnComplete(_) => {
- saw_turn_complete = true;
- }
- _ => {}
- }
- }
-
- let started_item = started_item.expect("context compaction item started");
- let completed_item = completed_item.expect("context compaction item completed");
- assert_eq!(started_item.id, completed_item.id);
- assert!(legacy_event);
- assert_eq!(compact_mock.requests().len(), 1);
-
- Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn remote_manual_compact_failure_emits_task_error_event() -> Result<()> {
- skip_if_no_network!(Ok(()));
-
- let harness = TestCodexHarness::with_builder(
- test_codex().with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing()),
- )
- .await?;
- let codex = harness.test().codex.clone();
-
- mount_sse_once(
- harness.server(),
- sse(vec![
- responses::ev_assistant_message("m1", "REMOTE_REPLY"),
- responses::ev_completed("resp-1"),
- ]),
- )
- .await;
-
- let compact_mock = responses::mount_compact_json_once(
- harness.server(),
- serde_json::json!({ "output": "invalid compact payload shape" }),
- )
- .await;
-
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "manual remote compact".into(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_event(&codex, |event| matches!(event, EventMsg::TurnComplete(_))).await;
-
- codex.submit(Op::Compact).await?;
-
- let error_message = wait_for_event_match(&codex, |event| match event {
- EventMsg::Error(err) => Some(err.message.clone()),
- _ => None,
- })
- .await;
- assert!(
- error_message.contains("Error running remote compact task"),
- "expected remote compact task error prefix, got {error_message}"
- );
- assert!(
- error_message.contains("invalid compact payload shape")
- || error_message.contains("invalid type: string"),
- "expected invalid compact payload details, got {error_message}"
- );
- wait_for_event(&codex, |event| matches!(event, EventMsg::TurnComplete(_))).await;
-
- assert_eq!(compact_mock.requests().len(), 1);
-
- Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-// TODO(ccunningham): Re-enable after the follow-up compaction behavior PR lands.
-// Current main behavior for rollout replacement-history persistence is known-incorrect.
-#[ignore = "behavior change covered in follow-up compaction PR"]
-async fn remote_compact_persists_replacement_history_in_rollout() -> Result<()> {
- skip_if_no_network!(Ok(()));
-
- let harness = TestCodexHarness::with_builder(
- test_codex().with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing()),
- )
- .await?;
- let codex = harness.test().codex.clone();
- let rollout_path = harness
- .test()
- .session_configured
- .rollout_path
- .clone()
- .expect("rollout path");
-
- let responses_mock = responses::mount_sse_once(
- harness.server(),
- responses::sse(vec![
- responses::ev_assistant_message("m1", "COMPACT_BASELINE_REPLY"),
- responses::ev_completed("resp-1"),
- ]),
- )
- .await;
-
- let compacted_history = vec![
- ResponseItem::Compaction {
- id: None,
- encrypted_content: "ENCRYPTED_COMPACTION_SUMMARY".to_string(),
- internal_chat_message_metadata_passthrough: None,
- },
- ResponseItem::Message {
- id: None,
- role: "assistant".to_string(),
- content: vec![ContentItem::OutputText {
- text: "COMPACTED_ASSISTANT_NOTE".to_string(),
- }],
- phase: None,
- internal_chat_message_metadata_passthrough: None,
- },
- ];
- let compact_mock = responses::mount_compact_json_once(
- harness.server(),
- serde_json::json!({ "output": compacted_history.clone() }),
- )
- .await;
-
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "needs compaction".into(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_event(&codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
-
- codex.submit(Op::Compact).await?;
- wait_for_event(&codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
-
- codex.submit(Op::Shutdown).await?;
- wait_for_event(&codex, |ev| matches!(ev, EventMsg::ShutdownComplete)).await;
-
- assert_eq!(responses_mock.requests().len(), 1);
- assert_eq!(compact_mock.requests().len(), 1);
-
- let rollout_text = fs::read_to_string(&rollout_path)?;
- let mut saw_compacted_history = false;
- for line in rollout_text
- .lines()
- .map(str::trim)
- .filter(|l| !l.is_empty())
- {
- let Ok(entry) = codex_rollout::parse_rollout_line(line) else {
- continue;
- };
- if let RolloutItem::Compacted(compacted) = entry.item
- && compacted.message.is_empty()
- && let Some(replacement_history) = compacted.replacement_history.as_ref()
- {
- let has_compaction_item = replacement_history.iter().any(|item| {
- matches!(
- &item.item,
- ResponseItem::Compaction {
- encrypted_content, ..
- }
- if encrypted_content == "ENCRYPTED_COMPACTION_SUMMARY"
- )
- });
- let has_compacted_assistant_note = replacement_history.iter().any(|item| {
- matches!(
- &item.item,
- ResponseItem::Message { role, content, .. }
- if role == "assistant"
- && content.iter().any(|part| matches!(
- part,
- ContentItem::OutputText { text } if text == "COMPACTED_ASSISTANT_NOTE"
- ))
- )
- });
- let has_permissions_developer_message = replacement_history.iter().any(|item| {
- matches!(
- &item.item,
- ResponseItem::Message { role, content, .. }
- if role == "developer"
- && content.iter().any(|part| matches!(
- part,
- ContentItem::InputText { text }
- if text.contains("<permissions instructions>")
- ))
- )
- });
-
- if has_compaction_item && has_compacted_assistant_note {
- assert!(
- !has_permissions_developer_message,
- "manual remote compact rollout replacement history should not inject permissions context"
- );
- saw_compacted_history = true;
- break;
- }
- }
- }
-
- assert!(
- saw_compacted_history,
- "expected rollout to persist remote compaction history"
- );
-
- Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn remote_compact_and_resume_refresh_stale_developer_instructions() -> Result<()> {
- skip_if_no_network!(Ok(()));
-
- let server = wiremock::MockServer::start().await;
- let stale_developer_message = "STALE_DEVELOPER_INSTRUCTIONS_SHOULD_BE_REMOVED";
- let managed_requirements = CloudConfigBundleFixture::loader_with_enterprise_requirement(
- r#"additional_developer_instructions = "MANAGED_DEVELOPER_INSTRUCTIONS""#,
- );
- let managed_message = "<managed_developer_instructions>\nMANAGED_DEVELOPER_INSTRUCTIONS\n</managed_developer_instructions>";
-
- let mut start_builder = test_codex()
- .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
- .with_cloud_config_bundle(managed_requirements.clone());
- let initial = start_builder.build(&server).await?;
- let home = initial.home.clone();
- let rollout_path = initial
- .session_configured
- .rollout_path
- .clone()
- .expect("rollout path");
-
- let responses_mock = responses::mount_sse_sequence(
- &server,
- vec![
- responses::sse(vec![
- responses::ev_assistant_message("m1", "BASELINE_REPLY"),
- responses::ev_completed("resp-1"),
- ]),
- responses::sse(vec![
- responses::ev_assistant_message("m2", "AFTER_COMPACT_REPLY"),
- responses::ev_completed("resp-2"),
- ]),
- responses::sse(vec![
- responses::ev_assistant_message("m3", "AFTER_RESUME_REPLY"),
- responses::ev_completed("resp-3"),
- ]),
- ],
- )
- .await;
-
- let compacted_history = vec![
- ResponseItem::Message {
- id: None,
- role: "developer".to_string(),
- content: vec![ContentItem::InputText {
- text: stale_developer_message.to_string(),
- }],
- phase: None,
- internal_chat_message_metadata_passthrough: None,
- },
- ResponseItem::Compaction {
- id: None,
- encrypted_content: "ENCRYPTED_COMPACTION_SUMMARY".to_string(),
- internal_chat_message_metadata_passthrough: None,
- },
- ];
- let compact_mock = responses::mount_compact_json_once(
- &server,
- serde_json::json!({ "output": compacted_history }),
- )
- .await;
-
- initial
- .codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "start remote compact flow".into(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_event(&initial.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
-
- initial.codex.submit(Op::Compact).await?;
- wait_for_event(&initial.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
-
- initial
- .codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "after compact in same session".into(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_event(&initial.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
-
- initial.codex.submit(Op::Shutdown).await?;
- wait_for_event(&initial.codex, |ev| {
- matches!(ev, EventMsg::ShutdownComplete)
- })
- .await;
-
- let mut resume_builder = test_codex()
- .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
- .with_cloud_config_bundle(managed_requirements);
- let resumed = resume_builder.resume(&server, home, rollout_path).await?;
-
- resumed
- .codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "after resume".into(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_event(&resumed.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
-
- assert_eq!(compact_mock.requests().len(), 1);
- let requests = responses_mock.requests();
- assert_eq!(requests.len(), 3, "expected three model requests");
- for request in &requests {
- assert_eq!(
- request
- .message_input_texts("developer")
- .into_iter()
- .filter(|message| message.contains("<managed_developer_instructions>"))
- .collect::<Vec<_>>(),
- vec![managed_message.to_string()],
- "Each model request should contain exactly one managed developer-instructions block, including after compaction and resume."
- );
- }
-
- let after_compact_request = &requests[1];
- let after_resume_request = &requests[2];
-
- let after_compact_body = after_compact_request.body_json().to_string();
- assert!(
- !after_compact_body.contains(stale_developer_message),
- "stale developer instructions should be removed immediately after compaction"
- );
- assert!(
- after_compact_body.contains("<permissions instructions>"),
- "fresh developer instructions should be present after compaction"
- );
- assert!(
- after_compact_body.contains("ENCRYPTED_COMPACTION_SUMMARY"),
- "compaction item should be present after compaction"
- );
-
- let after_resume_body = after_resume_request.body_json().to_string();
- assert!(
- !after_resume_body.contains(stale_developer_message),
- "stale developer instructions should be removed after resume"
- );
- assert!(
- after_resume_body.contains("<permissions instructions>"),
- "fresh developer instructions should be present after resume"
- );
- assert!(
- after_resume_body.contains("ENCRYPTED_COMPACTION_SUMMARY"),
- "compaction item should persist after resume"
- );
-
- Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn remote_compact_refreshes_stale_developer_instructions_without_resume() -> Result<()> {
- skip_if_no_network!(Ok(()));
-
- let server = wiremock::MockServer::start().await;
- let stale_developer_message = "STALE_DEVELOPER_INSTRUCTIONS_SHOULD_BE_REMOVED";
-
- let mut builder = test_codex().with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing());
- let test = builder.build(&server).await?;
-
- let responses_mock = responses::mount_sse_sequence(
- &server,
- vec![
- responses::sse(vec![
- responses::ev_assistant_message("m1", "BASELINE_REPLY"),
- responses::ev_completed("resp-1"),
- ]),
- responses::sse(vec![
- responses::ev_assistant_message("m2", "AFTER_COMPACT_REPLY"),
- responses::ev_completed("resp-2"),
- ]),
- ],
- )
- .await;
-
- let compacted_history = vec![
- ResponseItem::Message {
- id: None,
- role: "developer".to_string(),
- content: vec![ContentItem::InputText {
- text: stale_developer_message.to_string(),
- }],
- phase: None,
- internal_chat_message_metadata_passthrough: None,
- },
- ResponseItem::Compaction {
- id: None,
- encrypted_content: "ENCRYPTED_COMPACTION_SUMMARY".to_string(),
- internal_chat_message_metadata_passthrough: None,
- },
- ];
- let compact_mock = responses::mount_compact_json_once(
- &server,
- serde_json::json!({ "output": compacted_history }),
- )
- .await;
-
- test.codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "start remote compact flow".into(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
-
- test.codex.submit(Op::Compact).await?;
- wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
-
- test.codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "after compact in same session".into(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
-
- assert_eq!(compact_mock.requests().len(), 1);
- let requests = responses_mock.requests();
- assert_eq!(requests.len(), 2, "expected two model requests");
-
- let after_compact_body = requests[1].body_json().to_string();
- assert!(
- !after_compact_body.contains(stale_developer_message),
- "stale developer instructions should be removed immediately after compaction"
- );
- assert!(
- after_compact_body.contains("<permissions instructions>"),
- "fresh developer instructions should be present after compaction"
- );
- assert!(
- after_compact_body.contains("ENCRYPTED_COMPACTION_SUMMARY"),
- "compaction item should be present after compaction"
- );
-
- Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn snapshot_request_shape_remote_pre_turn_compaction_restates_realtime_start() -> Result<()> {
- skip_if_no_network!(Ok(()));
-
- let server = wiremock::MockServer::start().await;
- let realtime_server = start_remote_realtime_server().await;
- let mut builder = remote_realtime_test_codex_builder(&realtime_server).with_config(|config| {
- config.model_auto_compact_token_limit = Some(200);
- });
- let test = builder.build(&server).await?;
-
- let responses_mock = responses::mount_sse_sequence(
- &server,
- vec![
- responses::sse(vec![
- responses::ev_assistant_message("m1", "REMOTE_FIRST_REPLY"),
- responses::ev_completed_with_tokens("r1", /*total_tokens*/ 500),
- ]),
- responses::sse(vec![
- responses::ev_assistant_message("m2", "REMOTE_SECOND_REPLY"),
- responses::ev_completed_with_tokens("r2", /*total_tokens*/ 80),
- ]),
- ],
- )
- .await;
- let compact_mock = responses::mount_compact_json_once(
- &server,
- serde_json::json!({
- "output": compacted_summary_only_output(
- "REMOTE_PRETURN_REALTIME_STILL_ACTIVE_SUMMARY"
- )
- }),
- )
- .await;
-
- start_realtime_conversation(test.codex.as_ref()).await?;
-
- test.codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "USER_ONE".to_string(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
-
- test.codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "USER_TWO".to_string(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
-
- assert_eq!(compact_mock.requests().len(), 1);
- let requests = responses_mock.requests();
- assert_eq!(requests.len(), 2, "expected two model requests");
-
- let compact_request = compact_mock.single_request();
- let post_compact_request = &requests[1];
- assert_request_contains_realtime_start(post_compact_request);
-
- insta::assert_snapshot!(
- "remote_pre_turn_compaction_restates_realtime_start_shapes",
- format_labeled_requests_snapshot(
- "Remote pre-turn auto-compaction while realtime remains active: compaction clears the reference baseline, so the follow-up request restates realtime-start instructions.",
- &[
- ("Remote Compaction Request", &compact_request),
- (
- "Remote Post-Compaction History Layout",
- post_compact_request
- ),
- ]
- )
- );
-
- close_realtime_conversation(test.codex.as_ref()).await?;
- realtime_server.shutdown().await;
- Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn remote_request_uses_custom_experimental_realtime_start_instructions() -> Result<()> {
- skip_if_no_network!(Ok(()));
-
- let server = wiremock::MockServer::start().await;
- let realtime_server = start_remote_realtime_server().await;
- let custom_instructions = "custom realtime start instructions";
- let mut builder = remote_realtime_test_codex_builder(&realtime_server).with_config({
- let custom_instructions = custom_instructions.to_string();
- move |config| {
- config.experimental_realtime_start_instructions = Some(custom_instructions);
- }
- });
- let test = builder.build(&server).await?;
-
- let responses_mock = responses::mount_sse_once(
- &server,
- responses::sse(vec![
- responses::ev_assistant_message("m1", "REMOTE_FIRST_REPLY"),
- responses::ev_completed("r1"),
- ]),
- )
- .await;
-
- start_realtime_conversation(test.codex.as_ref()).await?;
-
- test.codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "USER_ONE".to_string(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
-
- assert_request_contains_custom_realtime_start(
- &responses_mock.single_request(),
- custom_instructions,
- );
-
- close_realtime_conversation(test.codex.as_ref()).await?;
- realtime_server.shutdown().await;
- Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn active_realtime_does_not_diff_changed_start_instructions_after_resume() -> Result<()> {
- skip_if_no_network!(Ok(()));
-
- let server = wiremock::MockServer::start().await;
- let initial_realtime_server = start_remote_realtime_server().await;
- let initial_instructions = "initial custom realtime start instructions";
- let mut initial_builder = remote_realtime_test_codex_builder(&initial_realtime_server)
- .with_config({
- let initial_instructions = initial_instructions.to_string();
- move |config| {
- config.experimental_realtime_start_instructions = Some(initial_instructions);
- }
- });
- let initial = initial_builder.build(&server).await?;
- let home = initial.home.clone();
- let rollout_path = initial
- .session_configured
- .rollout_path
- .clone()
- .expect("rollout path");
- let responses_mock = responses::mount_sse_sequence(
- &server,
- vec![
- responses::sse(vec![responses::ev_completed("r1")]),
- responses::sse(vec![responses::ev_completed("r2")]),
- ],
- )
- .await;
-
- start_realtime_conversation(initial.codex.as_ref()).await?;
- initial.submit_turn("USER_ONE").await?;
- close_realtime_conversation(initial.codex.as_ref()).await?;
- initial.codex.submit(Op::Shutdown).await?;
- wait_for_event(&initial.codex, |ev| {
- matches!(ev, EventMsg::ShutdownComplete)
- })
- .await;
- initial_realtime_server.shutdown().await;
-
- let resumed_realtime_server = start_remote_realtime_server().await;
- let changed_instructions = "changed custom realtime start instructions";
- let mut resume_builder = remote_realtime_test_codex_builder(&resumed_realtime_server)
- .with_config({
- let changed_instructions = changed_instructions.to_string();
- move |config| {
- config.experimental_realtime_start_instructions = Some(changed_instructions);
- }
- });
- let resumed = resume_builder.resume(&server, home, rollout_path).await?;
-
- start_realtime_conversation(resumed.codex.as_ref()).await?;
- resumed.submit_turn("USER_TWO").await?;
-
- let requests = responses_mock.requests();
- assert_eq!(requests.len(), 2, "expected one request per session");
- assert_request_contains_custom_realtime_start(&requests[0], initial_instructions);
- let resumed_body = requests[1].body_json().to_string();
- assert!(
- resumed_body.contains(initial_instructions),
- "expected resumed history to retain the original realtime instructions"
- );
- assert!(
- !resumed_body.contains(changed_instructions),
- "did not expect an active-to-active instruction change to emit a diff"
- );
-
- close_realtime_conversation(resumed.codex.as_ref()).await?;
- resumed_realtime_server.shutdown().await;
- Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn snapshot_request_shape_remote_manual_compact_restates_realtime_start() -> Result<()> {
- skip_if_no_network!(Ok(()));
-
- let server = wiremock::MockServer::start().await;
- let realtime_server = start_remote_realtime_server().await;
- let mut builder = remote_realtime_test_codex_builder(&realtime_server);
- let test = builder.build(&server).await?;
-
- let responses_mock = responses::mount_sse_sequence(
- &server,
- vec![
- responses::sse(vec![
- responses::ev_assistant_message("m1", "REMOTE_FIRST_REPLY"),
- responses::ev_completed_with_tokens("r1", /*total_tokens*/ 60),
- ]),
- responses::sse(vec![
- responses::ev_assistant_message("m2", "REMOTE_SECOND_REPLY"),
- responses::ev_completed_with_tokens("r2", /*total_tokens*/ 80),
- ]),
- ],
- )
- .await;
- let compact_mock = responses::mount_compact_json_once(
- &server,
- serde_json::json!({
- "output": compacted_summary_only_output(
- "REMOTE_MANUAL_REALTIME_STILL_ACTIVE_SUMMARY"
- )
- }),
- )
- .await;
-
- start_realtime_conversation(test.codex.as_ref()).await?;
-
- test.codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "USER_ONE".to_string(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
-
- test.codex.submit(Op::Compact).await?;
- wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
-
- test.codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "USER_TWO".to_string(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
-
- assert_eq!(compact_mock.requests().len(), 1);
- let requests = responses_mock.requests();
- assert_eq!(requests.len(), 2, "expected two model requests");
-
- let compact_request = compact_mock.single_request();
- let post_compact_request = &requests[1];
- assert_request_contains_realtime_start(post_compact_request);
-
- insta::assert_snapshot!(
- "remote_manual_compact_restates_realtime_start_shapes",
- format_labeled_requests_snapshot(
- "Remote manual /compact while realtime remains active: the next regular turn restates realtime-start instructions after compaction clears the baseline.",
- &[
- ("Remote Compaction Request", &compact_request),
- (
- "Remote Post-Compaction History Layout",
- post_compact_request
- ),
- ]
- )
- );
-
- close_realtime_conversation(test.codex.as_ref()).await?;
- realtime_server.shutdown().await;
- Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn snapshot_request_shape_remote_mid_turn_compaction_does_not_restate_realtime_end()
--> Result<()> {
- skip_if_no_network!(Ok(()));
-
- let server = wiremock::MockServer::start().await;
- let realtime_server = start_remote_realtime_server().await;
- let mut builder = remote_realtime_test_codex_builder(&realtime_server).with_config(|config| {
- config.model_auto_compact_token_limit = Some(200);
- });
- let test = builder.build(&server).await?;
-
- let responses_mock = responses::mount_sse_sequence(
- &server,
- vec![
- responses::sse(vec![
- responses::ev_assistant_message("setup", "REMOTE_SETUP_REPLY"),
- responses::ev_completed_with_tokens("setup-response", /*total_tokens*/ 60),
- ]),
- responses::sse(vec![
- responses::ev_function_call("call-remote-mid-turn", DUMMY_FUNCTION_NAME, "{}"),
- responses::ev_completed_with_tokens("r1", /*total_tokens*/ 500),
- ]),
- responses::sse(vec![
- responses::ev_assistant_message("m2", "REMOTE_MID_TURN_FINAL_REPLY"),
- responses::ev_completed_with_tokens("r2", /*total_tokens*/ 80),
- ]),
- ],
- )
- .await;
- let compact_mock = responses::mount_compact_json_once(
- &server,
- serde_json::json!({
- "output": compacted_summary_only_output(
- "REMOTE_MID_TURN_REALTIME_CLOSED_SUMMARY"
- )
- }),
- )
- .await;
-
- start_realtime_conversation(test.codex.as_ref()).await?;
-
- test.codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "SETUP_USER".to_string(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
-
- close_realtime_conversation(test.codex.as_ref()).await?;
-
- test.codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "USER_TWO".to_string(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
-
- assert_eq!(compact_mock.requests().len(), 1);
- let requests = responses_mock.requests();
- assert_eq!(requests.len(), 3, "expected three model requests");
-
- let second_turn_request = &requests[1];
- let compact_request = compact_mock.single_request();
- let post_compact_request = &requests[2];
- assert_request_contains_realtime_end(second_turn_request);
- assert!(
- !post_compact_request
- .body_json()
- .to_string()
- .contains("<realtime_conversation>"),
- "did not expect post-compaction history to restate realtime instructions once the current turn had already established an inactive baseline"
- );
-
- insta::assert_snapshot!(
- "remote_mid_turn_compaction_does_not_restate_realtime_end_shapes",
- format_labeled_requests_snapshot(
- "Remote mid-turn continuation compaction after realtime was closed before the turn: the initial second-turn request emits realtime-end instructions, but the continuation request does not restate them after compaction because the current turn already established the inactive baseline.",
- &[
- ("Second Turn Initial Request", second_turn_request),
- ("Remote Compaction Request", &compact_request),
- (
- "Remote Post-Compaction History Layout",
- post_compact_request
- ),
- ]
- )
+ let follow_up_request = response_requests.last().expect("follow-up request missing");
+ assert_eq!(
+ item_create_time(follow_up_request, "hello remote compact"),
+ original_user_create_time
);
-
- realtime_server.shutdown().await;
- Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-// TODO(ccunningham): Update once remote pre-turn compaction includes incoming user input.
-async fn snapshot_request_shape_remote_pre_turn_compaction_including_incoming_user_message()
--> Result<()> {
- skip_if_no_network!(Ok(()));
-
- let harness = TestCodexHarness::with_builder(
- test_codex()
- .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
- .with_config(|config| {
- config.model_auto_compact_token_limit = Some(200);
- }),
- )
- .await?;
- let codex = harness.test().codex.clone();
-
- let responses_mock = responses::mount_sse_sequence(
- harness.server(),
- vec![
- responses::sse(vec![
- responses::ev_assistant_message("m1", "REMOTE_FIRST_REPLY"),
- responses::ev_completed_with_tokens("r1", /*total_tokens*/ 60),
- ]),
- responses::sse(vec![
- responses::ev_assistant_message("m2", "REMOTE_SECOND_REPLY"),
- responses::ev_completed_with_tokens("r2", /*total_tokens*/ 500),
- ]),
- responses::sse(vec![
- responses::ev_assistant_message("m3", "REMOTE_FINAL_REPLY"),
- responses::ev_completed_with_tokens("r3", /*total_tokens*/ 80),
- ]),
- ],
- )
- .await;
-
- let compact_mock = responses::mount_compact_user_history_with_summary_once(
- harness.server(),
- &summary_with_prefix("REMOTE_PRE_TURN_SUMMARY"),
- )
- .await;
-
- for user in ["USER_ONE", "USER_TWO", "USER_THREE"] {
- if user == "USER_THREE" {
- core_test_support::submit_thread_settings(
- &codex,
- ThreadSettingsOverrides {
- environments: Some(local_selections(
- test_path_buf(PRETURN_CONTEXT_DIFF_CWD).abs(),
- )),
- ..Default::default()
- },
- )
- .await?;
- }
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: user.to_string(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_event(&codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
- }
-
- assert_eq!(compact_mock.requests().len(), 1);
- let requests = responses_mock.requests();
assert_eq!(
- requests.len(),
- 3,
- "expected user, user, and post-compact turn"
+ item_create_time(follow_up_request, &delegated_task_ciphertext),
+ delegated_task_create_time
);
-
- let compact_request = compact_mock.single_request();
- insta::assert_snapshot!(
- "remote_pre_turn_compaction_including_incoming_shapes",
- format_labeled_requests_snapshot(
- "Remote pre-turn auto-compaction with a context override emits the context diff in the compact request while excluding the incoming user message.",
- &[
- ("Remote Compaction Request", &compact_request),
- ("Remote Post-Compaction History Layout", &requests[2]),
- ]
- )
+ assert!(
+ item_create_time(follow_up_request, "after compact")
+ .as_f64()
+ .is_some_and(|create_time| create_time > 0.0)
);
- assert_eq!(
- requests[2]
- .message_input_texts("user")
+ assert!(
+ follow_up_request
+ .inputs_of_type("agent_message")
.iter()
- .filter(|text| text.as_str() == "USER_THREE")
- .count(),
- 1,
- "post-compaction request should contain incoming user exactly once from runtime append"
+ .any(|item| item["content"][1]["encrypted_content"].as_str()
+ == Some(delegated_task_ciphertext.as_str())),
+ "expected v2 follow-up request to retain the encrypted delegated task"
);
-
- Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn snapshot_request_shape_remote_pre_turn_compaction_strips_incoming_model_switch()
--> Result<()> {
- skip_if_no_network!(Ok(()));
-
- let previous_model = "gpt-5.4";
- let next_model = "gpt-5.2";
- let harness = TestCodexHarness::with_builder(
- test_codex()
- .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
- .with_model(previous_model)
- .with_config(|config| {
- config.model_auto_compact_token_limit = Some(200);
- }),
- )
- .await?;
- let codex = harness.test().codex.clone();
-
- let initial_turn_request_mock = responses::mount_sse_once(
- harness.server(),
- responses::sse(vec![
- responses::ev_assistant_message("m1", "BEFORE_SWITCH_REPLY"),
- responses::ev_completed_with_tokens("r1", /*total_tokens*/ 500),
- ]),
- )
- .await;
- let post_compact_turn_request_mock = responses::mount_sse_once(
- harness.server(),
- responses::sse(vec![
- responses::ev_assistant_message("m2", "AFTER_SWITCH_REPLY"),
- responses::ev_completed_with_tokens("r2", /*total_tokens*/ 80),
- ]),
- )
- .await;
- let compact_mock = responses::mount_compact_user_history_with_summary_once(
- harness.server(),
- &summary_with_prefix("REMOTE_SWITCH_SUMMARY"),
- )
- .await;
-
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "BEFORE_SWITCH_USER".to_string(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_event(&codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
-
- core_test_support::submit_thread_settings(
- &codex,
- ThreadSettingsOverrides {
- model: Some(next_model.to_string()),
- ..Default::default()
- },
- )
- .await?;
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "AFTER_SWITCH_USER".to_string(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_event(&codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
-
- assert_eq!(
- compact_mock.requests().len(),
- 1,
- "expected a single remote pre-turn compaction request"
+ assert!(
+ follow_up_request
+ .inputs_of_type("agent_message")
+ .iter()
+ .any(|item| item["content"][1]["encrypted_content"].as_str()
+ == Some(descendant_followup_ciphertext)),
+ "expected v2 follow-up request to retain the descendant-authored follow-up task"
);
- assert_eq!(
- initial_turn_request_mock.requests().len(),
- 1,
- "expected initial turn request"
+ assert!(
+ follow_up_request
+ .inputs_of_type("agent_message")
+ .iter()
+ .all(|item| !item.to_string().contains("child progress")),
+ "expected v2 follow-up request to omit the child progress update"
);
- assert_eq!(
- post_compact_turn_request_mock.requests().len(),
- 1,
- "expected post-compaction follow-up request"
+ assert!(
+ follow_up_request
+ .inputs_of_type("agent_message")
+ .iter()
+ .all(|item| !item.to_string().contains("child completion")),
+ "expected v2 follow-up request to omit the child completion"
);
-
- let initial_turn_request = initial_turn_request_mock.single_request();
- let compact_request = compact_mock.single_request();
- let post_compact_turn_request = post_compact_turn_request_mock.single_request();
- let compact_body = compact_request.body_json().to_string();
+ let follow_up_body = follow_up_request.body_json().to_string();
assert!(
- !compact_body.contains("AFTER_SWITCH_USER"),
- "current behavior excludes incoming user from the pre-turn remote compaction request"
+ follow_up_body.contains("\"type\":\"compaction\""),
+ "expected follow-up request to preserve the compaction item"
);
assert!(
- !compact_body.contains("<model_switch>"),
- "pre-turn remote compaction request should strip incoming model-switch update item"
+ follow_up_body.contains("ENCRYPTED_CONTEXT_COMPACTION_SUMMARY"),
+ "expected follow-up request to include the compaction payload"
);
-
- let follow_up_body = post_compact_turn_request.body_json().to_string();
+ assert!(!follow_up_body.contains("IGNORED_COMPACT_REPLY"));
assert!(
- follow_up_body.contains("BEFORE_SWITCH_USER"),
- "post-compaction follow-up should preserve older user messages when they fit"
+ follow_up_body.contains("hello remote compact"),
+ "expected v2 follow-up request to preserve retained original user messages"
);
assert!(
- follow_up_body.contains("AFTER_SWITCH_USER"),
- "post-compaction follow-up should preserve incoming user message via runtime append"
+ follow_up_request.input().windows(2).any(|items| {
+ items[0]["role"] == "user"
+ && items[0]["content"][0]["text"] == "retained image source"
+ && items[1]["role"] == "developer"
+ && items[1]["content"][0]["text"] == user_notice
+ }),
+ "expected v2 compaction to retain the user image and its adjacent resize notice"
);
assert!(
- follow_up_body.contains("<model_switch>"),
- "post-compaction follow-up should include the model-switch update item"
+ !follow_up_body.contains(unlisted_notice),
+ "expected v2 compaction to drop unlisted developer notices"
);
-
- insta::assert_snapshot!(
- "remote_pre_turn_compaction_strips_incoming_model_switch_shapes",
- format_labeled_requests_snapshot(
- "Remote pre-turn compaction during model switch currently excludes incoming user input, strips incoming <model_switch> from the compact request payload, and restores it in the post-compaction follow-up request.",
- &[
- ("Initial Request (Previous Model)", &initial_turn_request),
- ("Remote Compaction Request", &compact_request),
- (
- "Remote Post-Compaction History Layout",
- &post_compact_turn_request
- ),
- ]
- )
+ assert!(
+ !follow_up_body.contains(tool_notice),
+ "expected v2 compaction to drop the resize notice with its tool output"
);
Ok(())
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-// TODO(ccunningham): Update once remote pre-turn compaction context-overflow handling includes
-// incoming user input and emits richer oversized-input messaging.
-async fn snapshot_request_shape_remote_pre_turn_compaction_context_window_exceeded() -> Result<()> {
+async fn remote_compact_v2_retries_failures_with_stream_retry_budget() -> Result<()> {
skip_if_no_network!(Ok(()));
let harness = TestCodexHarness::with_builder(
test_codex()
+ .with_history_mode(ThreadHistoryMode::Paginated)
.with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
.with_config(|config| {
- config.model_auto_compact_token_limit = Some(200);
+ let _ = config.features.enable(Feature::RemoteCompactionV2);
+ config.model_provider.request_max_retries = Some(0);
+ config.model_provider.stream_max_retries = Some(2);
}),
)
.await?;
let codex = harness.test().codex.clone();
- let responses_mock = responses::mount_sse_sequence(
- harness.server(),
- vec![responses::sse(vec![
- responses::ev_assistant_message("m1", "REMOTE_FIRST_REPLY"),
- responses::ev_completed_with_tokens("r1", /*total_tokens*/ 500),
- ])],
- )
- .await;
-
- let compact_mock = responses::mount_compact_response_once(
- harness.server(),
- ResponseTemplate::new(400).set_body_json(serde_json::json!({
- "error": {
- "code": "context_length_exceeded",
- "message": "Your input exceeds the context window of this model. Please adjust your input and try again."
- }
- })),
- )
- .await;
- let post_compact_turn_mock = responses::mount_sse_once(
+ let responses_mock = responses::mount_response_sequence(
harness.server(),
- responses::sse(vec![
- responses::ev_assistant_message("m2", "REMOTE_POST_COMPACT_SHOULD_NOT_RUN"),
- responses::ev_completed_with_tokens("r2", /*total_tokens*/ 80),
- ]),
+ vec![
+ responses::sse_response(responses::sse(vec![
+ responses::ev_assistant_message("m1", "FIRST_REMOTE_REPLY"),
+ responses::ev_completed("resp-1"),
+ ])),
+ ResponseTemplate::new(500).set_body_string("first compact open failed"),
+ responses::sse_response(responses::sse(vec![serde_json::json!({
+ "type": "response.output_item.done",
+ "item": {
+ "type": "compaction",
+ "encrypted_content": "FAILED_COMPACT_SUMMARY",
+ }
+ })])),
+ responses::sse_response(responses::sse(vec![
+ serde_json::json!({
+ "type": "response.output_item.done",
+ "item": {
+ "type": "compaction",
+ "encrypted_content": "RETRIED_COMPACT_SUMMARY",
+ }
+ }),
+ responses::ev_completed("resp-compact-retry"),
+ ])),
+ responses::sse_response(responses::sse(vec![
+ responses::ev_assistant_message("m2", "AFTER_COMPACT_REPLY"),
+ responses::ev_completed("resp-2"),
+ ])),
+ ],
)
.await;
codex
.start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "USER_ONE".to_string(),
+ text: "hello remote compact".into(),
text_elements: Vec::new(),
}]))
.await?;
- wait_for_event(&codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
+ wait_for_turn_complete(&codex).await;
+
+ codex.submit(Op::Compact).await?;
+ wait_for_turn_complete(&codex).await;
codex
.start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "USER_TWO".to_string(),
+ text: "after compact".into(),
text_elements: Vec::new(),
}]))
.await?;
- let error_message = wait_for_event_match(&codex, |event| match event {
- EventMsg::Error(err) => Some(err.message.clone()),
- _ => None,
- })
- .await;
- wait_for_event(&codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
+ wait_for_turn_complete(&codex).await;
- assert_eq!(compact_mock.requests().len(), 1);
- let requests = responses_mock.requests();
+ let response_requests = responses_mock.requests();
assert_eq!(
- requests.len(),
- 1,
- "expected no post-compaction follow-up turn request after compact failure"
- );
- assert!(
- post_compact_turn_mock.requests().is_empty(),
- "expected turn to stop after compaction failure"
+ 5,
+ response_requests.len(),
+ "expected initial turn, failed open, failed stream, compact retry, and follow-up turn"
);
+ for compact_request in &response_requests[1..=3] {
+ assert_eq!("/v1/responses", compact_request.path());
+ let compact_metadata: Value = serde_json::from_str(
+ &compact_request
+ .header("x-codex-turn-metadata")
+ .expect("v2 compact request should include turn metadata"),
+ )?;
+ assert_eq!(compact_metadata["window_number"].as_u64(), Some(0));
+ assert!(compact_metadata["context_window_id"].as_str().is_some());
+ assert!(
+ compact_request
+ .body_json()
+ .to_string()
+ .contains("\"type\":\"compaction_trigger\""),
+ "expected v2 compaction request to include the compaction_trigger item"
+ );
+ }
- let include_attempt_request = compact_mock.single_request();
- insta::assert_snapshot!(
- "remote_pre_turn_compaction_context_window_exceeded_shapes",
- format_labeled_requests_snapshot(
- "Remote pre-turn auto-compaction context-window failure: compaction request excludes the incoming user message and the turn errors.",
- &[(
- "Remote Compaction Request (Incoming User Excluded)",
- &include_attempt_request
- ),]
- )
+ let follow_up_request = response_requests.last().expect("follow-up request missing");
+ let follow_up_body = follow_up_request.body_json().to_string();
+ assert!(
+ follow_up_body.contains("RETRIED_COMPACT_SUMMARY"),
+ "expected follow-up request to include the retried compaction payload"
);
assert!(
- error_message.to_lowercase().contains("context window"),
- "expected context window failure to surface, got {error_message}"
+ !follow_up_body.contains("FAILED_COMPACT_SUMMARY"),
+ "expected failed compaction attempt output to be discarded"
);
Ok(())
}
+#[test_case(false; "manual")]
+#[test_case(true; "automatic")]
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn remote_pre_turn_compact_response_seeds_turn_state() -> Result<()> {
+async fn remote_compact_v2_rewrites_multiple_trailing_function_call_outputs(
+ automatic: bool,
+) -> Result<()> {
skip_if_no_network!(Ok(()));
+ let first_user_message = "turn with retained tool call";
+ let second_user_message = "turn with parallel tool calls";
+ let retained_call_id = "retained-call";
+ let first_trimmed_call_id = "first-trimmed-call";
+ let second_trimmed_call_id = "second-trimmed-call";
+ let retained_output = "retained tool output";
+
let harness = TestCodexHarness::with_builder(
test_codex()
.with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
.with_config(|config| {
- config.model_auto_compact_token_limit = Some(200);
+ config.model_context_window = Some(2_000);
+ config.model_auto_compact_token_limit = Some(200_000);
}),
)
.await?;
let codex = harness.test().codex.clone();
- let responses_mock = responses::mount_response_sequence(
- harness.server(),
- vec![
- responses::sse_response(responses::sse(vec![
- responses::ev_assistant_message("m1", "BEFORE_COMPACT_REPLY"),
- responses::ev_completed_with_tokens("r1", /*total_tokens*/ 500),
- ])),
- responses::sse_response(responses::sse(vec![
- responses::ev_assistant_message("m2", "AFTER_COMPACT_REPLY"),
- responses::ev_completed_with_tokens("r2", /*total_tokens*/ 80),
- ])),
- ],
- )
- .await;
- let compact_mock = responses::mount_compact_response_once(
+ let initial_mock = mount_sse_once(
harness.server(),
- ResponseTemplate::new(200)
- .insert_header("content-type", "application/json")
- .insert_header(TURN_STATE_HEADER, "compact-state")
- .set_body_json(json!({
- "output": compacted_summary_only_output("PRE_TURN_COMPACT_SUMMARY"),
- })),
- )
- .await;
+ sse(vec![responses::ev_completed_with_tokens(
+ "initial-response",
+ if automatic { 500_000 } else { 100 },
+ )]),
+ )
+ .await;
+ harness.test().submit_turn("initial turn").await?;
+ let _ = initial_mock.single_request();
+ let history = [
+ json!({"type": "message", "role": "user", "content": [{"type": "input_text", "text": first_user_message}]}),
+ json!({"type": "function_call", "call_id": retained_call_id, "name": "exec_command", "arguments": "{}"}),
+ json!({"type": "function_call_output", "call_id": retained_call_id, "output": retained_output}),
+ json!({"type": "message", "role": "user", "content": [{"type": "input_text", "text": second_user_message}]}),
+ json!({"type": "function_call", "call_id": first_trimmed_call_id, "name": "exec_command", "arguments": "{}"}),
+ json!({"type": "function_call", "call_id": second_trimmed_call_id, "name": "exec_command", "arguments": "{}"}),
+ json!({"type": "function_call_output", "call_id": first_trimmed_call_id, "output": "x".repeat(12_000)}),
+ json!({"type": "function_call_output", "call_id": second_trimmed_call_id, "output": "y".repeat(12_000)}),
+ ]
+ .into_iter()
+ .map(serde_json::from_value)
+ .collect::<serde_json::Result<Vec<ResponseItem>>>()?;
+ codex.inject_response_items(history).await?;
- // Phase 1: the first turn raises usage above the pre-turn compact threshold.
- // Phase 2: the next turn compacts before sampling and establishes turn state.
- for text in ["BEFORE_COMPACT_USER", "AFTER_COMPACT_USER"] {
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: text.to_string(),
- text_elements: Vec::new(),
- }]))
- .await?;
+ let mut response_bodies = vec![sse(vec![
+ json!({
+ "type": "response.output_item.done",
+ "item": {"type": "compaction", "encrypted_content": "REMOTE_COMPACT_SUMMARY"},
+ }),
+ responses::ev_completed("response-compact"),
+ ])];
+ if automatic {
+ response_bodies.push(responses::sse_completed("after-compact"));
+ }
+ let compact_mock = responses::mount_sse_sequence(harness.server(), response_bodies).await;
+
+ if automatic {
+ harness.test().submit_text_turn("after compact").await?;
+ } else {
+ codex.submit(Op::Compact).await?;
wait_for_turn_complete(&codex).await;
}
- // Phase 3: compact starts empty, and its returned state is sent to the first sample.
+ let requests = compact_mock.requests();
+ assert_eq!(requests.len(), if automatic { 2 } else { 1 });
+ let compact_request = &requests[0];
assert_eq!(
- compact_mock.single_request().header(TURN_STATE_HEADER),
- None
+ compact_request.inputs_of_type("compaction_trigger").len(),
+ 1
);
- let requests = responses_mock.requests();
- assert_eq!(requests.len(), 2);
- assert_eq!(requests[0].header(TURN_STATE_HEADER), None);
+ let user_messages = compact_request.message_input_texts("user");
+ assert!(
+ user_messages
+ .iter()
+ .any(|message| message == first_user_message)
+ );
+ assert!(
+ user_messages
+ .iter()
+ .any(|message| message == second_user_message)
+ );
+ assert!(
+ !user_messages
+ .iter()
+ .any(|message| message == "after compact")
+ );
+ if automatic {
+ let followup_metadata: Value = serde_json::from_str(
+ &requests[1]
+ .header("x-codex-turn-metadata")
+ .context("follow-up request metadata")?,
+ )?;
+ assert_eq!(followup_metadata["request_kind"], "turn");
+ }
+ assert!(compact_request.has_function_call(retained_call_id));
assert_eq!(
- requests[1].header(TURN_STATE_HEADER).as_deref(),
- Some("compact-state")
+ compact_request
+ .function_call_output_text(retained_call_id)
+ .as_deref(),
+ Some(retained_output),
+ "expected compact request to keep the older function output unchanged"
+ );
+ assert!(
+ compact_request.has_function_call(first_trimmed_call_id)
+ && compact_request.has_function_call(second_trimmed_call_id),
+ "expected compact request to retain both trailing parallel function calls"
+ );
+ assert_eq!(
+ compact_request.function_call_output_text(first_trimmed_call_id),
+ Some(CONTEXT_WINDOW_TRUNCATED_OUTPUT_MESSAGE.to_string()),
+ "expected compact request to rewrite the first trailing function call output"
+ );
+ assert_eq!(
+ compact_request.function_call_output_text(second_trimmed_call_id),
+ Some(CONTEXT_WINDOW_TRUNCATED_OUTPUT_MESSAGE.to_string()),
+ "expected compact request to rewrite the second trailing function call output"
+ );
+
+ assert_eq!(
+ compact_request.inputs_of_type("function_call").len(),
+ 3,
+ "expected all function calls after rewriting trailing outputs"
+ );
+ assert_eq!(
+ compact_request.inputs_of_type("function_call_output").len(),
+ 3,
+ "expected all function call outputs after rewriting trailing outputs"
);
Ok(())
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn remote_mid_turn_compact_v1_sends_turn_state_over_http() -> Result<()> {
+async fn active_realtime_refreshes_changed_start_instructions_only_after_compaction() -> Result<()>
+{
skip_if_no_network!(Ok(()));
- let harness = TestCodexHarness::with_builder(
- test_codex()
- .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
- .with_config(|config| {
- config.model_auto_compact_token_limit = Some(200);
- }),
- )
- .await?;
- let codex = harness.test().codex.clone();
- let responses_mock = responses::mount_response_sequence(
- harness.server(),
- vec![
- responses::sse_response(responses::sse(vec![
- responses::ev_function_call("call-before-compact", DUMMY_FUNCTION_NAME, "{}"),
- responses::ev_completed_with_tokens("r1", /*total_tokens*/ 500),
- ]))
- .insert_header(TURN_STATE_HEADER, "sampling-state"),
- responses::sse_response(responses::sse(vec![
- responses::ev_function_call("call-after-compact", DUMMY_FUNCTION_NAME, "{}"),
- responses::ev_completed_with_tokens("r2", /*total_tokens*/ 80),
- ]))
- .insert_header(TURN_STATE_HEADER, "continuation-state"),
- responses::sse_response(responses::sse(vec![
- responses::ev_assistant_message("m1", "FINAL_REPLY"),
- responses::ev_completed_with_tokens("r3", /*total_tokens*/ 80),
- ])),
+ let server = wiremock::MockServer::start().await;
+ let initial_realtime_server = start_remote_realtime_server().await;
+ let initial_instructions = "initial custom realtime start instructions";
+ let mut initial_builder = remote_realtime_test_codex_builder(&initial_realtime_server)
+ .with_config({
+ let initial_instructions = initial_instructions.to_string();
+ move |config| {
+ config.experimental_realtime_start_instructions = Some(initial_instructions);
+ }
+ });
+ let initial = initial_builder.build(&server).await?;
+ let home = initial.home.clone();
+ let rollout_path = initial
+ .session_configured
+ .rollout_path
+ .clone()
+ .expect("rollout path");
+ let responses_mock = responses::mount_sse_sequence(
+ &server,
+ vec![
+ responses::sse(vec![responses::ev_completed("r1")]),
+ responses::sse(vec![responses::ev_completed("r2")]),
+ responses::sse(vec![
+ json!({
+ "type": "response.output_item.done",
+ "item": {"type": "compaction", "encrypted_content": "realtime-summary"},
+ }),
+ responses::ev_completed("r-compact"),
+ ]),
+ responses::sse(vec![responses::ev_completed("r3")]),
],
)
.await;
- let compact_mock = responses::mount_compact_response_once(
- harness.server(),
- ResponseTemplate::new(200)
- .insert_header("content-type", "application/json")
- .insert_header(TURN_STATE_HEADER, "compact-state")
- .set_body_json(json!({
- "output": compacted_summary_only_output("MID_TURN_COMPACT_SUMMARY"),
- })),
- )
+
+ start_realtime_conversation(initial.codex.as_ref()).await?;
+ initial.submit_turn("USER_ONE").await?;
+ close_realtime_conversation(initial.codex.as_ref()).await?;
+ initial.codex.submit(Op::Shutdown).await?;
+ wait_for_event(&initial.codex, |ev| {
+ matches!(ev, EventMsg::ShutdownComplete)
+ })
.await;
+ initial_realtime_server.shutdown().await;
- // Phase 1: sampling mints state and crosses the token limit with a pending tool follow-up.
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "RUN_WITH_MID_TURN_COMPACT".to_string(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_turn_complete(&codex).await;
+ let resumed_realtime_server = start_remote_realtime_server().await;
+ let changed_instructions = "changed custom realtime start instructions";
+ let mut resume_builder = remote_realtime_test_codex_builder(&resumed_realtime_server)
+ .with_config({
+ let changed_instructions = changed_instructions.to_string();
+ move |config| {
+ config.experimental_realtime_start_instructions = Some(changed_instructions);
+ }
+ });
+ let resumed = resume_builder.resume(&server, home, rollout_path).await?;
- // Phase 2: v1 compact receives the state established by sampling.
- let compact_request = compact_mock.single_request();
- assert_eq!(compact_request.path(), "/v1/responses/compact");
- assert_eq!(
- compact_request.header(TURN_STATE_HEADER).as_deref(),
- Some("sampling-state")
- );
+ start_realtime_conversation(resumed.codex.as_ref()).await?;
+ resumed.submit_turn("USER_TWO").await?;
+ resumed.codex.submit(Op::Compact).await?;
+ wait_for_turn_complete(&resumed.codex).await;
+ resumed.submit_turn("USER_THREE").await?;
- // Phase 3: every remaining request keeps replaying that first value.
let requests = responses_mock.requests();
- assert_eq!(requests.len(), 3);
- assert_eq!(requests[0].header(TURN_STATE_HEADER), None);
- assert_eq!(
- requests[1].header(TURN_STATE_HEADER).as_deref(),
- Some("sampling-state")
+ assert_eq!(requests.len(), 4);
+ assert_request_contains_custom_realtime_start(&requests[0], initial_instructions);
+ let resumed_body = requests[1].body_json().to_string();
+ assert!(
+ resumed_body.contains(initial_instructions),
+ "expected resumed history to retain the original realtime instructions"
+ );
+ assert!(
+ !resumed_body.contains(changed_instructions),
+ "did not expect an active-to-active instruction change to emit a diff"
);
+ assert_eq!(requests[2].inputs_of_type("compaction_trigger").len(), 1);
assert_eq!(
- requests[2].header(TURN_STATE_HEADER).as_deref(),
- Some("sampling-state")
+ requests[3].inputs_of_type("compaction")[0]["encrypted_content"],
+ "realtime-summary"
);
+ assert_request_contains_custom_realtime_start(&requests[3], changed_instructions);
+ assert!(!requests[3].body_contains_text(initial_instructions));
+ close_realtime_conversation(resumed.codex.as_ref()).await?;
+ resumed_realtime_server.shutdown().await;
Ok(())
}
@@ -4666,305 +1590,3 @@ async fn remote_mid_turn_compact_v2_sends_turn_state_over_websocket() -> Result<
server.shutdown().await;
Ok(())
}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn snapshot_request_shape_remote_mid_turn_continuation_compaction() -> Result<()> {
- skip_if_no_network!(Ok(()));
-
- let harness = TestCodexHarness::with_builder(
- test_codex()
- .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
- .with_config(|config| {
- config.model_auto_compact_token_limit = Some(200);
- }),
- )
- .await?;
- let codex = harness.test().codex.clone();
-
- let responses_mock = responses::mount_sse_sequence(
- harness.server(),
- vec![
- responses::sse(vec![
- responses::ev_function_call("call-remote-mid-turn", DUMMY_FUNCTION_NAME, "{}"),
- responses::ev_completed_with_tokens("r1", /*total_tokens*/ 500),
- ]),
- responses::sse(vec![
- responses::ev_assistant_message("m2", "REMOTE_MID_TURN_FINAL_REPLY"),
- responses::ev_completed_with_tokens("r2", /*total_tokens*/ 80),
- ]),
- ],
- )
- .await;
-
- let compact_mock = responses::mount_compact_user_history_with_summary_once(
- harness.server(),
- &summary_with_prefix("REMOTE_MID_TURN_SUMMARY"),
- )
- .await;
-
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "USER_ONE".to_string(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_event(&codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
-
- assert_eq!(compact_mock.requests().len(), 1);
- let requests = responses_mock.requests();
- assert_eq!(
- requests.len(),
- 2,
- "expected initial and post-compact requests"
- );
-
- let compact_request = compact_mock.single_request();
- insta::assert_snapshot!(
- "remote_mid_turn_compaction_shapes",
- format_labeled_requests_snapshot(
- "Remote mid-turn continuation compaction after tool output: compact request includes tool artifacts and the follow-up request includes the returned compaction item.",
- &[
- ("Remote Compaction Request", &compact_request),
- ("Remote Post-Compaction History Layout", &requests[1]),
- ]
- )
- );
-
- Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn snapshot_request_shape_remote_mid_turn_compaction_summary_only_reinjects_context()
--> Result<()> {
- skip_if_no_network!(Ok(()));
-
- let harness = TestCodexHarness::with_builder(
- test_codex()
- .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
- .with_config(|config| {
- config.model_auto_compact_token_limit = Some(200);
- }),
- )
- .await?;
- let codex = harness.test().codex.clone();
-
- let initial_turn_request_mock = responses::mount_sse_once(
- harness.server(),
- responses::sse(vec![
- responses::ev_function_call("call-remote-summary-only", DUMMY_FUNCTION_NAME, "{}"),
- responses::ev_completed_with_tokens("r1", /*total_tokens*/ 500),
- ]),
- )
- .await;
- let post_compact_turn_request_mock = responses::mount_sse_once(
- harness.server(),
- responses::sse(vec![
- responses::ev_assistant_message("m2", "REMOTE_SUMMARY_ONLY_FINAL_REPLY"),
- responses::ev_completed_with_tokens("r2", /*total_tokens*/ 80),
- ]),
- )
- .await;
-
- let compacted_history = vec![ResponseItem::Compaction {
- id: None,
- encrypted_content: summary_with_prefix("REMOTE_SUMMARY_ONLY"),
- internal_chat_message_metadata_passthrough: None,
- }];
- let compact_mock = responses::mount_compact_json_once(
- harness.server(),
- serde_json::json!({ "output": compacted_history }),
- )
- .await;
-
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "USER_ONE".to_string(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_event(&codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
-
- assert_eq!(compact_mock.requests().len(), 1);
- assert_eq!(
- initial_turn_request_mock.requests().len(),
- 1,
- "expected initial turn request"
- );
- assert_eq!(
- post_compact_turn_request_mock.requests().len(),
- 1,
- "expected post-compaction request"
- );
-
- let compact_request = compact_mock.single_request();
- let post_compact_turn_request = post_compact_turn_request_mock.single_request();
- insta::assert_snapshot!(
- "remote_mid_turn_compaction_summary_only_reinjects_context_shapes",
- format_labeled_requests_snapshot(
- "Remote mid-turn compaction where compact output has only a compaction item: continuation layout reinjects context before that compaction item.",
- &[
- ("Remote Compaction Request", &compact_request),
- (
- "Remote Post-Compaction History Layout",
- &post_compact_turn_request
- ),
- ]
- )
- );
-
- Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn snapshot_request_shape_remote_mid_turn_compaction_multi_summary_reinjects_above_last_summary()
--> Result<()> {
- skip_if_no_network!(Ok(()));
-
- let harness = TestCodexHarness::with_builder(
- test_codex()
- .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
- .with_pre_build_hook(allow_echo_commands)
- .with_config(|config| {
- config.model_auto_compact_token_limit = Some(200);
- }),
- )
- .await?;
- let codex = harness.test().codex.clone();
-
- let setup_turn_request_mock = responses::mount_sse_once(
- harness.server(),
- responses::sse(vec![
- responses::ev_assistant_message("setup", "REMOTE_SETUP_REPLY"),
- responses::ev_completed_with_tokens("setup-response", /*total_tokens*/ 60),
- ]),
- )
- .await;
- let second_turn_request_mock = responses::mount_sse_once(
- harness.server(),
- responses::sse(vec![
- responses::ev_exec_command_call("call-remote-multi-summary", "echo multi-summary"),
- responses::ev_completed_with_tokens("r1", /*total_tokens*/ 1_000),
- ]),
- )
- .await;
-
- let compact_mock = responses::mount_compact_user_history_with_summary_sequence(
- harness.server(),
- vec![
- summary_with_prefix("REMOTE_OLDER_SUMMARY"),
- summary_with_prefix("REMOTE_LATEST_SUMMARY"),
- ],
- )
- .await;
-
- codex
- .start_or_steer_turn(unrestricted_user_turn(vec![UserInput::Text {
- text: "USER_ONE".to_string(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_event(&codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
-
- codex.submit(Op::Compact).await?;
- wait_for_event(&codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
-
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "USER_TWO".to_string(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_event(&codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
-
- assert_eq!(compact_mock.requests().len(), 2);
- assert_eq!(
- setup_turn_request_mock.requests().len(),
- 1,
- "expected setup turn request"
- );
- assert_eq!(
- second_turn_request_mock.requests().len(),
- 1,
- "expected second-turn pre-compaction request"
- );
-
- let compact_requests = compact_mock.requests();
- assert_eq!(
- compact_requests.len(),
- 2,
- "expected one setup compact and one mid-turn compact request"
- );
- let compact_request = compact_requests[1].clone();
- let second_turn_request = second_turn_request_mock.single_request();
- assert!(
- compact_request.body_contains_text("REMOTE_OLDER_SUMMARY"),
- "older summary should round-trip from conversation history into the next compact request"
- );
- insta::assert_snapshot!(
- "remote_mid_turn_compaction_multi_summary_reinjects_above_last_summary_shapes",
- format_labeled_requests_snapshot(
- "After a prior manual /compact produced an older remote compaction item, the next turn hits remote auto-compaction before the next sampling request. The compact request carries forward that earlier compaction item, and the next sampling request shows the latest compaction item with context reinjected before USER_TWO.",
- &[
- ("Remote Compaction Request", &compact_request),
- (
- "Second Turn Request (After Compaction)",
- &second_turn_request
- ),
- ]
- )
- );
-
- Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn snapshot_request_shape_remote_manual_compact_without_previous_user_messages() -> Result<()>
-{
- skip_if_no_network!(Ok(()));
-
- let harness = TestCodexHarness::with_builder(
- test_codex().with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing()),
- )
- .await?;
- let codex = harness.test().codex.clone();
-
- let responses_mock = responses::mount_sse_once(
- harness.server(),
- responses::sse(vec![
- responses::ev_assistant_message("m1", "REMOTE_MANUAL_EMPTY_FOLLOW_UP_REPLY"),
- responses::ev_completed_with_tokens("r1", /*total_tokens*/ 80),
- ]),
- )
- .await;
-
- let compact_mock =
- responses::mount_compact_json_once(harness.server(), serde_json::json!({ "output": [] }))
- .await;
-
- codex.submit(Op::Compact).await?;
- wait_for_event(&codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
-
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "USER_ONE".to_string(),
- text_elements: Vec::new(),
- }]))
- .await?;
- wait_for_event(&codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
-
- assert_eq!(
- compact_mock.requests().len(),
- 0,
- "manual /compact without prior user should not issue a remote compaction request"
- );
- let follow_up_request = responses_mock.single_request();
- insta::assert_snapshot!(
- "remote_manual_compact_without_prev_user_shapes",
- format_labeled_requests_snapshot(
- "Remote manual /compact with no prior user turn skips the remote compact request; the follow-up turn carries canonical context and new user message.",
- &[("Remote Post-Compaction History Layout", &follow_up_request)]
- )
- );
-
- Ok(())
-}
diff --git a/codex-rs/core/tests/suite/compact_remote_parity.rs b/codex-rs/core/tests/suite/compact_remote_parity.rs
deleted file mode 100644
index 3c5f1606a5..0000000000
--- a/codex-rs/core/tests/suite/compact_remote_parity.rs
+++ /dev/null
@@ -1,1216 +0,0 @@
-use super::compact::allow_echo_commands;
-use codex_core::TurnInputRequest;
-use std::fs;
-use std::path::Path;
-use std::path::PathBuf;
-
-use anyhow::Result;
-use codex_features::Feature;
-use codex_history::RolloutItem;
-use codex_login::CodexAuth;
-use codex_protocol::config_types::ServiceTier;
-use codex_protocol::models::PermissionProfile;
-use codex_protocol::protocol::AskForApproval;
-use codex_protocol::protocol::EventMsg;
-use codex_protocol::protocol::Op;
-use codex_protocol::protocol::ThreadSettingsOverrides;
-use codex_protocol::user_input::UserInput;
-use core_test_support::hooks::trust_discovered_hooks;
-use core_test_support::responses;
-use core_test_support::responses::ResponseMock;
-use core_test_support::responses::strip_response_item_ids_from_json;
-use core_test_support::skip_if_no_network;
-use core_test_support::test_codex::TestCodexHarness;
-use core_test_support::test_codex::test_codex;
-use core_test_support::wait_for_event;
-use pretty_assertions::assert_eq;
-use serde_json::Value;
-use serde_json::json;
-
-const FIXED_CWD: &str = "/tmp/codex_remote_compaction_parity_workspace";
-const IMAGE_URL: &str = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+/p9sAAAAASUVORK5CYII=";
-const SUMMARY: &str = "REMOTE_COMPACTION_PARITY_ENCRYPTED_SUMMARY";
-const DUMMY_FUNCTION_NAME: &str = "test_tool";
-const USER_INSTRUCTIONS: &str = "PARITY_USER_INSTRUCTIONS";
-
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-enum Mode {
- Legacy,
- V2,
-}
-
-#[derive(Clone, Copy, Debug)]
-enum AuthCase {
- ChatGpt,
- ApiKey,
-}
-
-impl AuthCase {
- fn build(self) -> CodexAuth {
- match self {
- AuthCase::ChatGpt => CodexAuth::create_dummy_chatgpt_auth_for_testing(),
- AuthCase::ApiKey => CodexAuth::from_api_key("dummy"),
- }
- }
-}
-
-#[derive(Clone, Copy, Debug)]
-struct RunSettings {
- auth: AuthCase,
- service_tier_fast: bool,
-}
-
-impl Default for RunSettings {
- fn default() -> Self {
- Self {
- auth: AuthCase::ChatGpt,
- service_tier_fast: false,
- }
- }
-}
-
-#[derive(Clone, Copy, Debug)]
-enum Step {
- Assistant,
- ReasoningAssistant,
- FunctionTool,
- ShellTool,
- ImageAssistant,
- WebSearchAssistant,
-}
-
-impl Step {
- fn label(self) -> &'static str {
- match self {
- Step::Assistant => "assistant",
- Step::ReasoningAssistant => "reasoning_assistant",
- Step::FunctionTool => "function_tool",
- Step::ShellTool => "shell_tool",
- Step::ImageAssistant => "image_assistant",
- Step::WebSearchAssistant => "web_search_assistant",
- }
- }
-}
-
-#[derive(Debug)]
-struct Scenario {
- name: &'static str,
- steps: &'static [Step],
-}
-
-#[derive(Debug)]
-struct Capture {
- compact_body: Value,
- follow_up_body: Value,
- replacement_history: Value,
- normal_response_requests: usize,
- compact_requests: usize,
-}
-
-const ASSISTANT_ONLY: &[Step] = &[Step::Assistant];
-const REASONING_IMAGE: &[Step] = &[Step::ReasoningAssistant, Step::ImageAssistant];
-const TOOL_MIX: &[Step] = &[Step::Assistant, Step::FunctionTool, Step::ShellTool];
-const FULL_MIX: &[Step] = &[
- Step::ReasoningAssistant,
- Step::FunctionTool,
- Step::ImageAssistant,
- Step::ShellTool,
- Step::WebSearchAssistant,
- Step::Assistant,
-];
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn remote_compaction_parity_manual_transcripts() -> Result<()> {
- skip_if_no_network!(Ok(()));
-
- let scenarios = [
- Scenario {
- name: "assistant_only",
- steps: ASSISTANT_ONLY,
- },
- Scenario {
- name: "reasoning_image",
- steps: REASONING_IMAGE,
- },
- Scenario {
- name: "tool_mix",
- steps: TOOL_MIX,
- },
- Scenario {
- name: "full_mix",
- steps: FULL_MIX,
- },
- ];
-
- for scenario in scenarios {
- compare_manual_scenario(&scenario, RunSettings::default()).await?;
- }
-
- Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn remote_compaction_parity_v2_api_key_sends_service_tier_upgrade() -> Result<()> {
- skip_if_no_network!(Ok(()));
-
- let scenario = Scenario {
- name: "api_key_service_tier",
- steps: TOOL_MIX,
- };
- let settings = RunSettings {
- auth: AuthCase::ApiKey,
- service_tier_fast: true,
- };
- let legacy = run_manual_session(&scenario, Mode::Legacy, settings).await?;
- let v2 = run_manual_session(&scenario, Mode::V2, settings).await?;
-
- assert_eq!(
- legacy.compact_body.get("service_tier"),
- None,
- "legacy /responses/compact should continue omitting service_tier for API-key auth"
- );
- assert_eq!(
- v2.compact_body.get("service_tier").and_then(Value::as_str),
- Some(ServiceTier::Fast.request_value()),
- "v2 compaction should send service_tier through /responses for API-key auth"
- );
-
- assert_compact_requests_eq_except_v2_service_tier("api-key service tier", &legacy, &v2);
- assert_follow_up_and_history_eq("api-key service tier", &legacy, &v2);
- Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn remote_compaction_parity_manual_hooks() -> Result<()> {
- skip_if_no_network!(Ok(()));
-
- let legacy = run_manual_hook_session(Mode::Legacy).await?;
- let v2 = run_manual_hook_session(Mode::V2).await?;
- assert_json_eq("manual compact hook payload parity mismatch", &legacy, &v2);
- Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn remote_compaction_parity_pre_turn_auto() -> Result<()> {
- skip_if_no_network!(Ok(()));
-
- let legacy = run_pre_turn_auto_session(Mode::Legacy).await?;
- let v2 = run_pre_turn_auto_session(Mode::V2).await?;
- assert_capture_eq("pre-turn auto", &legacy, &v2);
- Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn remote_compaction_parity_mid_turn_auto() -> Result<()> {
- skip_if_no_network!(Ok(()));
-
- let legacy = run_mid_turn_auto_session(Mode::Legacy).await?;
- let v2 = run_mid_turn_auto_session(Mode::V2).await?;
- assert_capture_eq("mid-turn auto", &legacy, &v2);
- Ok(())
-}
-
-async fn compare_manual_scenario(scenario: &Scenario, settings: RunSettings) -> Result<()> {
- let legacy = run_manual_session(scenario, Mode::Legacy, settings).await?;
- let v2 = run_manual_session(scenario, Mode::V2, settings).await?;
- assert_capture_eq(scenario.name, &legacy, &v2);
- Ok(())
-}
-
-fn assert_capture_eq(label: &str, legacy: &Capture, v2: &Capture) {
- assert_eq!(
- legacy.compact_requests, 1,
- "legacy compact endpoint should be called exactly once for {label}",
- );
- assert_eq!(
- v2.compact_requests, 0,
- "v2 should not call /responses/compact for {label}",
- );
-
- let legacy_compact = compact_request_view(&legacy.compact_body, Mode::Legacy);
- let v2_compact = compact_request_view(&v2.compact_body, Mode::V2);
- assert_json_eq(
- &format!("compact request parity mismatch for {label}"),
- &legacy_compact,
- &v2_compact,
- );
-
- let legacy_follow_up = follow_up_request_view(&legacy.follow_up_body);
- let v2_follow_up = follow_up_request_view(&v2.follow_up_body);
- assert_json_eq(
- &format!("post-compact follow-up request parity mismatch for {label}"),
- &legacy_follow_up,
- &v2_follow_up,
- );
-
- assert_json_eq(
- &format!("replacement history parity mismatch for {label}"),
- &legacy.replacement_history,
- &v2.replacement_history,
- );
-
- println!(
- "PARITY_OK scenario={} normal_response_requests={} compact_input_items={} replacement_history_items={} follow_up_input_items={}",
- label,
- legacy.normal_response_requests,
- compact_input_len(&legacy.compact_body, Mode::Legacy),
- replacement_history_len(&legacy.replacement_history),
- follow_up_input_len(&legacy.follow_up_body)
- );
-}
-
-fn assert_compact_requests_eq_except_v2_service_tier(label: &str, legacy: &Capture, v2: &Capture) {
- assert_eq!(
- legacy.compact_requests, 1,
- "legacy compact endpoint should be called exactly once for {label}",
- );
- assert_eq!(
- v2.compact_requests, 0,
- "v2 should not call /responses/compact for {label}",
- );
-
- let legacy_compact = compact_request_view(&legacy.compact_body, Mode::Legacy);
- let mut v2_compact = compact_request_view(&v2.compact_body, Mode::V2);
- remove_object_field(&mut v2_compact, "service_tier");
- assert_json_eq(
- &format!("compact request parity mismatch for {label} after service_tier upgrade"),
- &legacy_compact,
- &v2_compact,
- );
-}
-
-fn assert_follow_up_and_history_eq(label: &str, legacy: &Capture, v2: &Capture) {
- let legacy_follow_up = follow_up_request_view(&legacy.follow_up_body);
- let v2_follow_up = follow_up_request_view(&v2.follow_up_body);
- assert_json_eq(
- &format!("post-compact follow-up request parity mismatch for {label}"),
- &legacy_follow_up,
- &v2_follow_up,
- );
-
- assert_json_eq(
- &format!("replacement history parity mismatch for {label}"),
- &legacy.replacement_history,
- &v2.replacement_history,
- );
-}
-
-async fn run_manual_session(
- scenario: &Scenario,
- mode: Mode,
- settings: RunSettings,
-) -> Result<Capture> {
- let mut response_bodies = response_bodies_for_scenario(scenario);
- if mode == Mode::V2 {
- response_bodies.push(compaction_v2_response_body());
- }
- response_bodies.push(after_compact_response_body(scenario.name));
-
- let harness = build_harness(mode, settings, /*hooks*/ false).await?;
- let rollout_path = rollout_path(&harness);
- let codex = harness.test().codex.clone();
-
- let responses_mock = responses::mount_sse_sequence(harness.server(), response_bodies).await;
- let compact_mock = mount_legacy_compact_if_needed(&harness, mode).await;
-
- for (idx, step) in scenario.steps.iter().enumerate() {
- submit_user_input(&codex, user_input_for_step(scenario.name, idx, *step)).await?;
- }
-
- codex.submit(Op::Compact).await?;
- wait_for_turn_complete(&codex).await;
-
- submit_user_input(
- &codex,
- vec![UserInput::Text {
- text: format!("{}_AFTER_COMPACT_USER", scenario.name),
- text_elements: Vec::new(),
- }],
- )
- .await?;
-
- capture_from_requests(
- mode,
- &codex,
- &rollout_path,
- &responses_mock,
- compact_mock.as_ref(),
- follow_up_index(responses_mock.requests().len()),
- )
- .await
-}
-
-async fn run_pre_turn_auto_session(mode: Mode) -> Result<Capture> {
- let response_bodies = match mode {
- Mode::Legacy => vec![
- responses::sse(vec![
- responses::ev_assistant_message("pre-turn-first-message", "PRE_TURN_FIRST_REPLY"),
- responses::ev_completed_with_tokens(
- "pre-turn-first-response",
- /*total_tokens*/ 500,
- ),
- ]),
- after_compact_response_body("pre_turn_auto"),
- ],
- Mode::V2 => vec![
- responses::sse(vec![
- responses::ev_assistant_message("pre-turn-first-message", "PRE_TURN_FIRST_REPLY"),
- responses::ev_completed_with_tokens(
- "pre-turn-first-response",
- /*total_tokens*/ 500,
- ),
- ]),
- compaction_v2_response_body(),
- after_compact_response_body("pre_turn_auto"),
- ],
- };
- let harness = build_auto_harness(mode).await?;
- let rollout_path = rollout_path(&harness);
- let codex = harness.test().codex.clone();
- let responses_mock = responses::mount_sse_sequence(harness.server(), response_bodies).await;
- let compact_mock = mount_legacy_compact_if_needed(&harness, mode).await;
-
- submit_user_input(
- &codex,
- vec![UserInput::Text {
- text: "pre_turn_auto_before".to_string(),
- text_elements: Vec::new(),
- }],
- )
- .await?;
- submit_user_input(
- &codex,
- vec![UserInput::Text {
- text: "pre_turn_auto_after".to_string(),
- text_elements: Vec::new(),
- }],
- )
- .await?;
-
- capture_from_requests(
- mode,
- &codex,
- &rollout_path,
- &responses_mock,
- compact_mock.as_ref(),
- follow_up_index(responses_mock.requests().len()),
- )
- .await
-}
-
-async fn run_mid_turn_auto_session(mode: Mode) -> Result<Capture> {
- let response_bodies = match mode {
- Mode::Legacy => vec![
- responses::sse(vec![
- responses::ev_function_call("mid-turn-call", DUMMY_FUNCTION_NAME, "{}"),
- responses::ev_completed_with_tokens(
- "mid-turn-call-response",
- /*total_tokens*/ 500,
- ),
- ]),
- after_compact_response_body("mid_turn_auto"),
- ],
- Mode::V2 => vec![
- responses::sse(vec![
- responses::ev_function_call("mid-turn-call", DUMMY_FUNCTION_NAME, "{}"),
- responses::ev_completed_with_tokens(
- "mid-turn-call-response",
- /*total_tokens*/ 500,
- ),
- ]),
- compaction_v2_response_body(),
- after_compact_response_body("mid_turn_auto"),
- ],
- };
- let harness = build_auto_harness(mode).await?;
- let rollout_path = rollout_path(&harness);
- let codex = harness.test().codex.clone();
- let responses_mock = responses::mount_sse_sequence(harness.server(), response_bodies).await;
- let compact_mock = mount_legacy_compact_if_needed(&harness, mode).await;
-
- submit_user_input(
- &codex,
- vec![UserInput::Text {
- text: "mid_turn_auto_user".to_string(),
- text_elements: Vec::new(),
- }],
- )
- .await?;
-
- capture_from_requests(
- mode,
- &codex,
- &rollout_path,
- &responses_mock,
- compact_mock.as_ref(),
- follow_up_index(responses_mock.requests().len()),
- )
- .await
-}
-
-async fn run_manual_hook_session(mode: Mode) -> Result<Value> {
- let response_bodies = match mode {
- Mode::Legacy => vec![responses::sse(vec![
- responses::ev_assistant_message("hook-first-message", "HOOK_FIRST_REPLY"),
- responses::ev_completed("hook-first-response"),
- ])],
- Mode::V2 => vec![
- responses::sse(vec![
- responses::ev_assistant_message("hook-first-message", "HOOK_FIRST_REPLY"),
- responses::ev_completed("hook-first-response"),
- ]),
- compaction_v2_response_body(),
- ],
- };
- let harness = build_harness(mode, RunSettings::default(), /*hooks*/ true).await?;
- let codex = harness.test().codex.clone();
- responses::mount_sse_sequence(harness.server(), response_bodies).await;
- let compact_mock = mount_legacy_compact_if_needed(&harness, mode).await;
-
- submit_user_input(
- &codex,
- vec![UserInput::Text {
- text: "manual_hooks_before".to_string(),
- text_elements: Vec::new(),
- }],
- )
- .await?;
- codex.submit(Op::Compact).await?;
- wait_for_turn_complete(&codex).await;
-
- if let Some(compact_mock) = compact_mock {
- assert_eq!(compact_mock.requests().len(), 1);
- }
-
- let home = harness.test().codex_home_path();
- let pre = hook_log_view(&home.join("pre_compact_manual_log.jsonl"))?;
- let post = hook_log_view(&home.join("post_compact_manual_log.jsonl"))?;
- Ok(json!({
- "pre": pre,
- "post": post,
- }))
-}
-
-async fn build_auto_harness(mode: Mode) -> Result<TestCodexHarness> {
- build_harness_inner(
- mode,
- RunSettings::default(),
- /*hooks*/ false,
- Some(200),
- )
- .await
-}
-
-async fn build_harness(mode: Mode, settings: RunSettings, hooks: bool) -> Result<TestCodexHarness> {
- build_harness_inner(mode, settings, hooks, /*auto_compact_limit*/ None).await
-}
-
-async fn build_harness_inner(
- mode: Mode,
- settings: RunSettings,
- hooks: bool,
- auto_compact_limit: Option<i64>,
-) -> Result<TestCodexHarness> {
- fs::create_dir_all(FIXED_CWD)?;
- let mut builder = test_codex()
- .with_auth(settings.auth.build())
- .with_pre_build_hook(allow_echo_commands)
- .with_pre_build_hook(|home| {
- fs::write(home.join("AGENTS.md"), USER_INSTRUCTIONS)
- .expect("write global instructions");
- });
- if hooks {
- builder = builder.with_pre_build_hook(write_manual_compact_hooks);
- }
- TestCodexHarness::with_builder(builder.with_config(move |config| {
- config.cwd = codex_utils_absolute_path::AbsolutePathBuf::from_absolute_path(PathBuf::from(
- FIXED_CWD,
- ))
- .expect("fixed cwd should be absolute");
- config.developer_instructions = Some("PARITY_DEVELOPER_INSTRUCTIONS".to_string());
- if settings.service_tier_fast {
- config.service_tier = Some(ServiceTier::Fast.request_value().to_string());
- }
- config.model_auto_compact_token_limit = auto_compact_limit;
- if hooks {
- trust_discovered_hooks(config);
- }
- if mode == Mode::Legacy {
- let _ = config.features.disable(Feature::RemoteCompactionV2);
- }
- }))
- .await
-}
-
-fn rollout_path(harness: &TestCodexHarness) -> PathBuf {
- harness
- .test()
- .session_configured
- .rollout_path
- .clone()
- .expect("rollout path")
-}
-
-async fn mount_legacy_compact_if_needed(
- harness: &TestCodexHarness,
- mode: Mode,
-) -> Option<ResponseMock> {
- match mode {
- Mode::Legacy => Some(
- responses::mount_compact_user_history_with_summary_once(harness.server(), SUMMARY)
- .await,
- ),
- Mode::V2 => None,
- }
-}
-
-fn follow_up_index(request_count: usize) -> usize {
- request_count.checked_sub(1).expect("follow-up request")
-}
-
-async fn capture_from_requests(
- mode: Mode,
- codex: &codex_core::CodexThread,
- rollout_path: &Path,
- responses_mock: &ResponseMock,
- compact_mock: Option<&ResponseMock>,
- follow_up_index: usize,
-) -> Result<Capture> {
- let response_requests = responses_mock.requests();
- let follow_up_body = response_requests
- .get(follow_up_index)
- .expect("follow-up request should be present")
- .body_json();
-
- let (compact_body, compact_requests) = match (mode, compact_mock) {
- (Mode::Legacy, Some(compact_mock)) => {
- let compact_requests = compact_mock.requests().len();
- (compact_mock.single_request().body_json(), compact_requests)
- }
- (Mode::V2, None) => {
- let compact_index = follow_up_index
- .checked_sub(1)
- .expect("v2 compact request should precede follow-up");
- (response_requests[compact_index].body_json(), 0)
- }
- (Mode::Legacy, None) | (Mode::V2, Some(_)) => panic!("unexpected compact mock state"),
- };
-
- codex.submit(Op::Shutdown).await?;
- wait_for_event(codex, |ev| matches!(ev, EventMsg::ShutdownComplete)).await;
-
- Ok(Capture {
- compact_body,
- follow_up_body,
- replacement_history: replacement_history_from_rollout(rollout_path)?,
- normal_response_requests: response_requests.len(),
- compact_requests,
- })
-}
-
-async fn submit_user_input(codex: &codex_core::CodexThread, items: Vec<UserInput>) -> Result<()> {
- codex
- .start_or_steer_turn(TurnInputRequest::user_input(items).with_thread_settings(
- ThreadSettingsOverrides {
- approval_policy: Some(AskForApproval::Never),
- permission_profile: Some(PermissionProfile::Disabled),
- ..Default::default()
- },
- ))
- .await?;
- wait_for_turn_complete(codex).await;
- Ok(())
-}
-
-async fn wait_for_turn_complete(codex: &codex_core::CodexThread) {
- wait_for_event(codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
-}
-
-fn user_input_for_step(scenario_name: &str, idx: usize, step: Step) -> Vec<UserInput> {
- let mut items = Vec::new();
- if matches!(step, Step::ImageAssistant) {
- items.push(UserInput::Image {
- image_url: IMAGE_URL.to_string(),
- detail: None,
- });
- }
- items.push(UserInput::Text {
- text: format!("{}_USER_TURN_{}_{}", scenario_name, idx, step.label()),
- text_elements: Vec::new(),
- });
- items
-}
-
-fn response_bodies_for_scenario(scenario: &Scenario) -> Vec<String> {
- scenario
- .steps
- .iter()
- .enumerate()
- .flat_map(|(idx, step)| response_bodies_for_step(scenario.name, idx, *step))
- .collect()
-}
-
-fn response_bodies_for_step(scenario_name: &str, idx: usize, step: Step) -> Vec<String> {
- let response_id = format!("{scenario_name}-{idx}-{}", step.label());
- match step {
- Step::Assistant => vec![responses::sse(vec![
- responses::ev_assistant_message(
- &format!("{response_id}-message"),
- &format!("{scenario_name} assistant reply {idx}"),
- ),
- responses::ev_completed(&format!("{response_id}-response")),
- ])],
- Step::ReasoningAssistant => vec![responses::sse(vec![
- responses::ev_reasoning_item(
- &format!("{response_id}-reasoning"),
- &["PARITY_REASONING_SUMMARY"],
- &["parity raw reasoning content"],
- ),
- responses::ev_assistant_message(
- &format!("{response_id}-message"),
- &format!("{scenario_name} reasoning reply {idx}"),
- ),
- responses::ev_completed(&format!("{response_id}-response")),
- ])],
- Step::FunctionTool => vec![
- responses::sse(vec![
- responses::ev_function_call(
- &format!("{response_id}-call"),
- DUMMY_FUNCTION_NAME,
- r#"{"case":"parity"}"#,
- ),
- responses::ev_completed(&format!("{response_id}-tool-response")),
- ]),
- responses::sse(vec![
- responses::ev_assistant_message(
- &format!("{response_id}-final-message"),
- &format!("{scenario_name} function follow-up {idx}"),
- ),
- responses::ev_completed(&format!("{response_id}-final-response")),
- ]),
- ],
- Step::ShellTool => vec![
- responses::sse(vec![
- responses::ev_exec_command_call(
- &format!("{response_id}-shell-call"),
- &format!("echo {scenario_name}_{idx}_SHELL_TOOL"),
- ),
- responses::ev_completed(&format!("{response_id}-shell-response")),
- ]),
- responses::sse(vec![
- responses::ev_assistant_message(
- &format!("{response_id}-final-message"),
- &format!("{scenario_name} shell follow-up {idx}"),
- ),
- responses::ev_completed(&format!("{response_id}-final-response")),
- ]),
- ],
- Step::ImageAssistant => vec![responses::sse(vec![
- responses::ev_assistant_message(
- &format!("{response_id}-message"),
- &format!("{scenario_name} image reply {idx}"),
- ),
- responses::ev_completed(&format!("{response_id}-response")),
- ])],
- Step::WebSearchAssistant => vec![responses::sse(vec![
- responses::ev_web_search_call_done(
- &format!("{response_id}-web-search"),
- "completed",
- &format!("{scenario_name} parity query"),
- ),
- responses::ev_assistant_message(
- &format!("{response_id}-message"),
- &format!("{scenario_name} web search reply {idx}"),
- ),
- responses::ev_completed(&format!("{response_id}-response")),
- ])],
- }
-}
-
-fn compaction_v2_response_body() -> String {
- responses::sse(vec![
- json!({
- "type": "response.output_item.done",
- "item": {
- "type": "compaction",
- "encrypted_content": SUMMARY,
- }
- }),
- responses::ev_completed("remote-compaction-v2-response"),
- ])
-}
-
-fn after_compact_response_body(scenario_name: &str) -> String {
- responses::sse(vec![
- responses::ev_assistant_message(
- &format!("{scenario_name}-after-compact-message"),
- &format!("{scenario_name} after compact reply"),
- ),
- responses::ev_completed(&format!("{scenario_name}-after-compact-response")),
- ])
-}
-
-fn compact_request_view(body: &Value, mode: Mode) -> Value {
- let mut input = body
- .get("input")
- .and_then(Value::as_array)
- .cloned()
- .expect("compact request should include input");
- if mode == Mode::V2 {
- let trigger = input
- .pop()
- .expect("v2 compact input should end with trigger");
- assert_eq!(
- trigger,
- json!({"type": "compaction_trigger"}),
- "v2 compact input should append exactly one compaction_trigger"
- );
- }
-
- let mut selected = selected_request_fields(body, SelectedFieldsMode::Compact);
- selected["input"] = normalize_value(strip_response_item_ids_from_json(Value::Array(input)));
- canonical_json(&normalize_value(selected))
-}
-
-fn follow_up_request_view(body: &Value) -> Value {
- let mut selected = selected_request_fields(body, SelectedFieldsMode::FollowUp);
- selected["input"] = normalize_value(strip_response_item_ids_from_json(
- body.get("input")
- .cloned()
- .expect("follow-up request should include input"),
- ));
- canonical_json(&normalize_value(selected))
-}
-
-fn replacement_history_from_rollout(path: &Path) -> Result<Value> {
- let rollout_text = fs::read_to_string(path)?;
- let mut replacement_history = None;
- for line in rollout_text
- .lines()
- .map(str::trim)
- .filter(|line| !line.is_empty())
- {
- let Ok(entry) = codex_rollout::parse_rollout_line(line) else {
- continue;
- };
- if let RolloutItem::Compacted(compacted) = entry.item
- && compacted.message.is_empty()
- && let Some(items) = compacted.replacement_history
- {
- let values = items
- .into_iter()
- .map(|item| serde_json::to_value(item.item).expect("serialize replacement item"))
- .collect::<Vec<_>>();
- replacement_history = Some(Value::Array(values));
- }
- }
- let replacement_history =
- replacement_history.expect("expected compacted rollout replacement history");
- Ok(canonical_json(&normalize_value(
- strip_response_item_ids_from_json(replacement_history),
- )))
-}
-
-fn write_manual_compact_hooks(home: &Path) {
- write_hook_script(
- &home.join("pre_compact_manual.py"),
- &home.join("pre_compact_manual_log.jsonl"),
- );
- write_hook_script(
- &home.join("post_compact_manual.py"),
- &home.join("post_compact_manual_log.jsonl"),
- );
- let hooks = json!({
- "hooks": {
- "PreCompact": [{
- "matcher": "manual",
- "hooks": [{
- "type": "command",
- "command": python_hook_command(&home.join("pre_compact_manual.py")),
- }]
- }],
- "PostCompact": [{
- "matcher": "manual",
- "hooks": [{
- "type": "command",
- "command": python_hook_command(&home.join("post_compact_manual.py")),
- }]
- }]
- }
- });
- fs::write(home.join("hooks.json"), hooks.to_string()).expect("write hooks.json");
-}
-
-fn write_hook_script(script_path: &Path, log_path: &Path) {
- let script = format!(
- r#"import json
-from pathlib import Path
-import sys
-
-payload = json.load(sys.stdin)
-with Path(r"{log_path}").open("a", encoding="utf-8") as handle:
- handle.write(json.dumps(payload, sort_keys=True) + "\n")
-"#,
- log_path = log_path.display(),
- );
- fs::write(script_path, script).expect("write compact hook script");
-}
-
-fn python_hook_command(script_path: &Path) -> String {
- format!("python3 \"{}\"", script_path.display())
-}
-
-fn hook_log_view(path: &Path) -> Result<Value> {
- let text = fs::read_to_string(path)?;
- let values = text
- .lines()
- .filter(|line| !line.trim().is_empty())
- .map(|line| {
- let payload: Value = serde_json::from_str(line).expect("parse compact hook payload");
- json!({
- "hook_event_name": payload["hook_event_name"].clone(),
- "trigger": payload["trigger"].clone(),
- "model": payload["model"].clone(),
- "has_reason": payload.get("reason").is_some(),
- "has_phase": payload.get("phase").is_some(),
- "has_implementation": payload.get("implementation").is_some(),
- "has_status": payload.get("status").is_some(),
- "has_error": payload.get("error").is_some(),
- })
- })
- .collect::<Vec<_>>();
- Ok(Value::Array(values))
-}
-
-#[derive(Clone, Copy)]
-enum SelectedFieldsMode {
- Compact,
- FollowUp,
-}
-
-fn selected_request_fields(body: &Value, mode: SelectedFieldsMode) -> Value {
- let mut selected = serde_json::Map::new();
- let fields: &[&str] = match mode {
- SelectedFieldsMode::Compact => &[
- "model",
- "instructions",
- "parallel_tool_calls",
- "reasoning",
- "service_tier",
- "prompt_cache_key",
- "text",
- "tools",
- "previous_response_id",
- ],
- SelectedFieldsMode::FollowUp => &[
- "model",
- "instructions",
- "parallel_tool_calls",
- "reasoning",
- "service_tier",
- "prompt_cache_key",
- "text",
- "tools",
- "tool_choice",
- "previous_response_id",
- "store",
- "stream",
- "include",
- ],
- };
- for field in fields {
- if let Some(value) = body.get(field) {
- selected.insert((*field).to_string(), normalize_value(value.clone()));
- }
- }
- Value::Object(selected)
-}
-
-fn normalize_value(value: Value) -> Value {
- match value {
- Value::String(text) => Value::String(normalize_string(&text)),
- Value::Array(values) => Value::Array(values.into_iter().map(normalize_value).collect()),
- Value::Object(map) => Value::Object(
- map.into_iter()
- .filter(|(key, _value)| key != "internal_chat_message_metadata_passthrough")
- .map(|(key, value)| (key, normalize_value(value)))
- .collect(),
- ),
- Value::Null | Value::Bool(_) | Value::Number(_) => value,
- }
-}
-
-fn normalize_string(value: &str) -> String {
- if is_uuid_like(value) {
- return "<UUID>".to_string();
- }
-
- let mut text = value.to_string();
- normalize_tmp_prefix_before_marker(&mut text, "/skills/");
- normalize_tmp_prefix_before_marker(&mut text, "\\skills\\");
-
- let mut search_start = 0;
- let chunk_id_prefix = "Chunk ID: ";
- while let Some(relative_start) = text[search_start..].find(chunk_id_prefix) {
- let value_start = search_start + relative_start + chunk_id_prefix.len();
- let value_end = text[value_start..]
- .find('\n')
- .map_or(text.len(), |offset| value_start + offset);
- let value = &text[value_start..value_end];
- if !value.is_empty() && value.chars().all(|ch| ch.is_ascii_hexdigit()) {
- text.replace_range(value_start..value_end, "<CHUNK_ID>");
- search_start = value_start + "<CHUNK_ID>".len();
- } else {
- search_start = value_end;
- }
- }
-
- let skills_open_tag = "<skills_instructions>";
- let skills_close_tag = "</skills_instructions>";
- let mut search_start = 0;
- while let Some(relative_start) = text[search_start..].find(skills_open_tag) {
- let body_start = search_start + relative_start + skills_open_tag.len();
- let Some(relative_end) = text[body_start..].find(skills_close_tag) else {
- break;
- };
- let body_end = body_start + relative_end;
- text.replace_range(body_start..body_end, "\n...\n");
- search_start = body_start + "\n...\n".len() + skills_close_tag.len();
- }
-
- let mut search_start = 0;
- let wall_time_prefix = "Wall time: ";
- let wall_time_suffix = " seconds";
- while let Some(relative_start) = text[search_start..].find(wall_time_prefix) {
- let value_start = search_start + relative_start + wall_time_prefix.len();
- let Some(relative_end) = text[value_start..].find(wall_time_suffix) else {
- break;
- };
- let value_end = value_start + relative_end;
- let value = &text[value_start..value_end];
- if !value.is_empty()
- && value.chars().any(|ch| ch.is_ascii_digit())
- && value.chars().all(|ch| ch.is_ascii_digit() || ch == '.')
- {
- text.replace_range(value_start..value_end, "<WALL_TIME>");
- search_start = value_start + "<WALL_TIME>".len() + wall_time_suffix.len();
- } else {
- search_start = value_end + wall_time_suffix.len();
- }
- }
- text
-}
-
-#[test]
-fn normalize_string_rewrites_dynamic_skill_instructions() {
- let text = normalize_string(
- "before\n<skills_instructions>\n## Skills\n- demo: Dynamic description\n\
- </skills_instructions>\nafter",
- );
-
- assert_eq!(
- text,
- "before\n<skills_instructions>\n...\n</skills_instructions>\nafter"
- );
-}
-
-fn is_uuid_like(value: &str) -> bool {
- let bytes = value.as_bytes();
- bytes.len() == 36
- && [8, 13, 18, 23].iter().all(|idx| bytes[*idx] == b'-')
- && bytes
- .iter()
- .enumerate()
- .all(|(idx, byte)| [8, 13, 18, 23].contains(&idx) || byte.is_ascii_hexdigit())
-}
-
-fn normalize_tmp_prefix_before_marker(text: &mut String, marker: &str) {
- let mut search_start = 0;
- while let Some(relative_marker_index) = text[search_start..].find(marker) {
- let marker_index = search_start + relative_marker_index;
- let prefix = &text[..marker_index];
- let windows_appdata_temp_start = prefix
- .rfind("/AppData/Local/Temp/.tmp")
- .and_then(|temp_index| prefix[..temp_index].rfind(":/Users/"))
- .and_then(|colon_index| colon_index.checked_sub(1))
- .or_else(|| {
- prefix
- .rfind("\\AppData\\Local\\Temp\\.tmp")
- .and_then(|temp_index| prefix[..temp_index].rfind(":\\Users\\"))
- .and_then(|colon_index| colon_index.checked_sub(1))
- });
- let start = prefix
- .rfind("/private/var/folders/")
- .or_else(|| prefix.rfind("/var/folders/"))
- .or_else(|| prefix.rfind("/private/tmp/.tmp"))
- .or_else(|| prefix.rfind("/tmp/.tmp"))
- .or(windows_appdata_temp_start);
- if let Some(start_index) = start {
- text.replace_range(start_index..marker_index, "<CODEX_HOME>");
- search_start = start_index + "<CODEX_HOME>".len() + marker.len();
- } else {
- search_start = marker_index + marker.len();
- }
- }
-}
-
-#[test]
-fn normalize_string_rewrites_linux_temp_skill_paths() {
- let text = normalize_string(
- "file: /tmp/.tmp5YYdK3/skills/.system/imagegen/SKILL.md and \
- /private/tmp/.tmpw3wqF9/skills/custom/SKILL.md",
- );
-
- assert_eq!(
- text,
- "file: <CODEX_HOME>/skills/.system/imagegen/SKILL.md and \
- <CODEX_HOME>/skills/custom/SKILL.md"
- );
-}
-
-#[test]
-fn normalize_string_rewrites_windows_temp_skill_paths() {
- let text = normalize_string(
- "file: C:/Users/runneradmin/AppData/Local/Temp/.tmpDuYxa3/skills/.system/imagegen/SKILL.md and \
- C:\\Users\\runneradmin\\AppData\\Local\\Temp\\.tmpiP36Yr\\skills\\custom\\SKILL.md",
- );
-
- assert_eq!(
- text,
- "file: <CODEX_HOME>/skills/.system/imagegen/SKILL.md and \
- <CODEX_HOME>\\skills\\custom\\SKILL.md"
- );
-}
-
-#[test]
-fn normalize_string_rewrites_shell_wall_times() {
- let text = normalize_string(
- "Exit code: 0\nWall time: 0 seconds\nOutput:\nok\n\
- Exit code: 0\nWall time: 0.1 seconds\nOutput:\nok",
- );
-
- assert_eq!(
- text,
- "Exit code: 0\nWall time: <WALL_TIME> seconds\nOutput:\nok\n\
- Exit code: 0\nWall time: <WALL_TIME> seconds\nOutput:\nok"
- );
-}
-
-fn canonical_json(value: &Value) -> Value {
- match value {
- Value::Object(map) => {
- let mut entries = map.iter().collect::<Vec<_>>();
- entries.sort_by_key(|(left_key, _)| *left_key);
- Value::Object(
- entries
- .into_iter()
- .map(|(key, value)| (key.clone(), canonical_json(value)))
- .collect(),
- )
- }
- Value::Array(values) => Value::Array(values.iter().map(canonical_json).collect()),
- Value::Null | Value::Bool(_) | Value::Number(_) | Value::String(_) => value.clone(),
- }
-}
-
-fn remove_object_field(value: &mut Value, field: &str) {
- if let Value::Object(map) = value {
- map.remove(field);
- }
-}
-
-fn assert_json_eq(label: &str, left: &Value, right: &Value) {
- if left != right {
- panic!("{}\n{}", label, first_json_diff(left, right, "$"));
- }
-}
-
-fn first_json_diff(left: &Value, right: &Value, path: &str) -> String {
- match (left, right) {
- (Value::Object(left_map), Value::Object(right_map)) => {
- let mut keys = left_map.keys().chain(right_map.keys()).collect::<Vec<_>>();
- keys.sort();
- keys.dedup();
- for key in keys {
- match (left_map.get(key), right_map.get(key)) {
- (Some(left_value), Some(right_value)) if left_value != right_value => {
- return first_json_diff(left_value, right_value, &format!("{path}.{key}"));
- }
- (None, Some(right_value)) => {
- return format!(
- "{path}.{key}: missing on left, right={}",
- short_json(right_value)
- );
- }
- (Some(left_value), None) => {
- return format!(
- "{path}.{key}: left={}, missing on right",
- short_json(left_value)
- );
- }
- (Some(_), Some(_)) | (None, None) => {}
- }
- }
- format!("{path}: object mismatch")
- }
- (Value::Array(left_values), Value::Array(right_values)) => {
- let len = left_values.len().min(right_values.len());
- for idx in 0..len {
- if left_values[idx] != right_values[idx] {
- return first_json_diff(
- &left_values[idx],
- &right_values[idx],
- &format!("{path}[{idx}]"),
- );
- }
- }
- if left_values.len() != right_values.len() {
- return format!(
- "{path}: array len left={} right={}",
- left_values.len(),
- right_values.len()
- );
- }
- format!("{path}: array mismatch")
- }
- _ => format!(
- "{path}: left={} right={}",
- short_json(left),
- short_json(right)
- ),
- }
-}
-
-fn short_json(value: &Value) -> String {
- let text = serde_json::to_string(value).expect("serialize short json value");
- const MAX_LEN: usize = 1000;
- if text.len() <= MAX_LEN {
- text
- } else {
- let prefix = text.chars().take(MAX_LEN).collect::<String>();
- format!("{prefix}...<{} chars>", text.len())
- }
-}
-
-fn compact_input_len(body: &Value, mode: Mode) -> usize {
- let len = body
- .get("input")
- .and_then(Value::as_array)
- .map(Vec::len)
- .unwrap_or_default();
- match mode {
- Mode::Legacy => len,
- Mode::V2 => len.saturating_sub(1),
- }
-}
-
-fn follow_up_input_len(body: &Value) -> usize {
- body.get("input")
- .and_then(Value::as_array)
- .map(Vec::len)
- .unwrap_or_default()
-}
-
-fn replacement_history_len(body: &Value) -> usize {
- body.as_array().map(Vec::len).unwrap_or_default()
-}
diff --git a/codex-rs/core/tests/suite/compact_remote_trimming.rs b/codex-rs/core/tests/suite/compact_remote_trimming.rs
new file mode 100644
index 0000000000..04ed0f552a
--- /dev/null
+++ b/codex-rs/core/tests/suite/compact_remote_trimming.rs
@@ -0,0 +1,131 @@
+//! Checks request-history trimming at the streamed remote compaction boundary.
+
+use super::*;
+use core_test_support::apps_test_server::configure_search_capable_model;
+use pretty_assertions::assert_eq;
+
+fn compact_response() -> String {
+ sse(vec![
+ json!({
+ "type": "response.output_item.done",
+ "item": {"type": "compaction", "encrypted_content": "TRIMMING_SUMMARY"},
+ }),
+ responses::ev_completed("compact"),
+ ])
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn remote_compact_v2_trims_tool_search_output_to_empty_tools_array() -> Result<()> {
+ skip_if_no_network!(Ok(()));
+
+ let call_id = "tool-search-1";
+ let tools = json!([{
+ "type": "namespace", "name": "codex_app", "description": "Codex app tools.",
+ "tools": [{
+ "type": "function", "name": "oversized_dynamic_tool", "description": "x".repeat(20_000),
+ "parameters": {"type": "object", "properties": {}, "additionalProperties": false},
+ "strict": false, "defer_loading": true,
+ }],
+ }]);
+ for (context_window, expected_tools) in [(200_000, &tools), (2_000, &json!([]))] {
+ let harness = TestCodexHarness::with_builder(
+ test_codex()
+ .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
+ .with_config(move |config| {
+ configure_search_capable_model(config);
+ config.model_context_window = Some(context_window);
+ }),
+ )
+ .await?;
+ let codex = &harness.test().codex;
+ let history = [
+ json!({"type": "message", "role": "user", "content": [{"type": "input_text", "text": "find the tool"}]}),
+ json!({"type": "tool_search_call", "call_id": call_id, "execution": "client", "arguments": {"query": "oversized deferred tool"}}),
+ json!({"type": "tool_search_output", "call_id": call_id, "status": "completed", "execution": "client", "tools": &tools}),
+ ]
+ .into_iter()
+ .map(serde_json::from_value)
+ .collect::<serde_json::Result<Vec<ResponseItem>>>()?;
+ codex.inject_response_items(history).await?;
+ let mock = mount_sse_once(harness.server(), compact_response()).await;
+ codex.submit(Op::Compact).await?;
+ wait_for_turn_complete(codex).await;
+
+ let request = mock.single_request();
+ assert_eq!(request.path(), "/v1/responses");
+ assert_eq!(request.inputs_of_type("compaction_trigger").len(), 1);
+ assert!(
+ request
+ .inputs_of_type("tool_search_call")
+ .iter()
+ .any(|item| item["call_id"] == call_id)
+ );
+ let output = request.tool_search_output(call_id);
+ assert_eq!(&output["tools"], expected_tools);
+ assert_eq!(output["call_id"], call_id);
+ assert_eq!(output["status"], "completed");
+ assert_eq!(output["execution"], "client");
+ }
+ Ok(())
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn remote_compact_v2_trim_estimate_uses_session_base_instructions() -> Result<()> {
+ skip_if_no_network!(Ok(()));
+
+ let short_instructions = "session base instructions";
+ let long_instructions = format!("{short_instructions} {}", "x".repeat(24_000));
+ let trailing_output = "x".repeat(12_000);
+ for (instructions, expected_output) in [
+ (short_instructions, trailing_output.as_str()),
+ (
+ long_instructions.as_str(),
+ CONTEXT_WINDOW_TRUNCATED_OUTPUT_MESSAGE,
+ ),
+ ] {
+ let harness = TestCodexHarness::with_builder(
+ test_codex()
+ .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
+ .with_config({
+ let instructions = instructions.to_string();
+ move |config| {
+ config.model_context_window = Some(8_000);
+ config.base_instructions = Some(instructions);
+ }
+ }),
+ )
+ .await?;
+ let codex = &harness.test().codex;
+ let history = [
+ json!({"type": "message", "role": "user", "content": [{"type": "input_text", "text": "older user"}]}),
+ json!({"type": "function_call", "call_id": "retained", "name": "exec_command", "arguments": "{}"}),
+ json!({"type": "function_call_output", "call_id": "retained", "output": "retained output"}),
+ json!({"type": "message", "role": "user", "content": [{"type": "input_text", "text": "user boundary"}]}),
+ json!({"type": "function_call", "call_id": "trailing", "name": "exec_command", "arguments": "{}"}),
+ json!({"type": "function_call_output", "call_id": "trailing", "output": &trailing_output}),
+ ]
+ .into_iter()
+ .map(serde_json::from_value)
+ .collect::<serde_json::Result<Vec<ResponseItem>>>()?;
+ codex.inject_response_items(history).await?;
+ let mock = mount_sse_once(harness.server(), compact_response()).await;
+ codex.submit(Op::Compact).await?;
+ wait_for_turn_complete(codex).await;
+
+ let request = mock.single_request();
+ assert_eq!(request.path(), "/v1/responses");
+ assert_eq!(request.inputs_of_type("compaction_trigger").len(), 1);
+ assert_eq!(request.instructions_text(), instructions);
+ assert!(request.has_function_call("retained"));
+ assert!(request.has_function_call("trailing"));
+ assert_eq!(
+ request.function_call_output_text("retained").as_deref(),
+ Some("retained output")
+ );
+ assert_eq!(
+ request.function_call_output_text("trailing").as_deref(),
+ Some(expected_output)
+ );
+ }
+ Ok(())
+}
diff --git a/codex-rs/core/tests/suite/cyber_access_program.rs b/codex-rs/core/tests/suite/cyber_access_program.rs
index 8c12c95e9b..6797f80655 100644
--- a/codex-rs/core/tests/suite/cyber_access_program.rs
+++ b/codex-rs/core/tests/suite/cyber_access_program.rs
@@ -188,49 +188,6 @@ async fn cyber_access_program_omits_api_key_and_spoofed_custom_provider() -> Res
Ok(())
}
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn cyber_access_program_survives_mid_turn_remote_compaction() -> Result<()> {
- core_test_support::skip_if_no_network!(Ok(()));
- let server = responses::start_mock_server().await;
- let requests = responses::mount_sse_sequence(
- &server,
- vec![
- responses::sse(vec![
- // A dummy tool response forces a follow-up without shell approvals.
- responses::ev_function_call("tool-1", "test_tool", "{}"),
- responses::ev_completed_with_tokens("resp-1", /*total_tokens*/ 100000000),
- ]),
- responses::sse(vec![responses::ev_completed("resp-2")]),
- ],
- )
- .await;
- let compact =
- responses::mount_compact_user_history_with_summary_once(&server, "compacted history").await;
- let test = test_codex()
- .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
- .with_config(|config| {
- let _ = config.features.disable(Feature::RemoteCompactionV2);
- })
- .build_with_auto_env(&server)
- .await?;
-
- submit(&test, Some(CyberAccessProgram::DaybreakBlue)).await?;
-
- assert_eq!(
- compact.single_request().body_json()["access_programs"],
- json!({"cyber": "daybreak_blue"})
- );
- assert_eq!(
- requests
- .requests()
- .iter()
- .map(|request| request.body_json()["access_programs"].clone())
- .collect::<Vec<_>>(),
- vec![json!({"cyber": "daybreak_blue"}); 2]
- );
- Ok(())
-}
-
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn cyber_access_program_survives_mid_turn_remote_compaction_v2() -> Result<()> {
core_test_support::skip_if_no_network!(Ok(()));
@@ -261,7 +218,7 @@ async fn cyber_access_program_survives_mid_turn_remote_compaction_v2() -> Result
let test = test_codex()
.with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
.with_config(|config| {
- let _ = config.features.enable(Feature::RemoteCompactionV2);
+ let _ = config.features.disable(Feature::RemoteCompactionV2);
config.model_auto_compact_token_limit = Some(200);
})
.build_with_auto_env(&server)
diff --git a/codex-rs/core/tests/suite/guardian_review.rs b/codex-rs/core/tests/suite/guardian_review.rs
index cad3d7ce11..0593841618 100644
--- a/codex-rs/core/tests/suite/guardian_review.rs
+++ b/codex-rs/core/tests/suite/guardian_review.rs
@@ -302,10 +302,6 @@ async fn guardian_review_compacts_with_summary_despite_parent_token_budget(
let server = start_mock_server().await;
let summary = "Guardian retained the user's standing authorization.";
- let compact = core_test_support::responses::mount_compact_user_history_with_summary_once(
- &server, summary,
- )
- .await;
let mut builder = test_codex()
.with_model_info_override("gpt-5.5", |model| {
model.auto_review_model_override = Some(model.slug.clone());
@@ -328,10 +324,6 @@ async fn guardian_review_compacts_with_summary_despite_parent_token_budget(
.features
.set_enabled(Feature::GuardianThreadContext, thread_owned)
.expect("configure Guardian context mode");
- config
- .features
- .disable(Feature::RemoteCompactionV2)
- .expect("use remote compaction");
config.model_context_window = Some(100_000);
config.model_auto_compact_token_limit = Some(50_000);
config.permissions.approval_policy = Constrained::allow_any(AskForApproval::OnRequest);
@@ -367,6 +359,13 @@ async fn guardian_review_compacts_with_summary_despite_parent_token_budget(
ev_function_call("exec-second", "exec_command", &command),
ev_completed("resp-parent-second"),
]),
+ sse(vec![
+ json!({
+ "type": "response.output_item.done",
+ "item": {"type": "compaction", "encrypted_content": summary},
+ }),
+ ev_completed("resp-guardian-compact"),
+ ]),
sse(vec![
ev_response_created("resp-guardian-second"),
ev_assistant_message("guardian-second", approval),
@@ -389,6 +388,7 @@ async fn guardian_review_compacts_with_summary_despite_parent_token_budget(
.iter()
.filter(|request| {
request.body_json()["client_metadata"]["x-openai-subagent"].as_str() == Some("guardian")
+ && request.inputs_of_type("compaction_trigger").is_empty()
})
.collect::<Vec<_>>();
assert_eq!(guardian_requests.len(), 2);
@@ -402,7 +402,12 @@ async fn guardian_review_compacts_with_summary_despite_parent_token_budget(
for request in &guardian_requests {
assert!(!request.has_content_kinds(&["token_budget.context_window"]));
}
- let compact_request = compact.single_request();
+ let compact_requests = requests
+ .iter()
+ .filter(|request| !request.inputs_of_type("compaction_trigger").is_empty())
+ .collect::<Vec<_>>();
+ assert_eq!(compact_requests.len(), 1);
+ let compact_request = compact_requests[0];
assert!(
compact_request
.message_input_texts("user")
diff --git a/codex-rs/core/tests/suite/mod.rs b/codex-rs/core/tests/suite/mod.rs
index 73c08c5452..0791c5be2e 100644
--- a/codex-rs/core/tests/suite/mod.rs
+++ b/codex-rs/core/tests/suite/mod.rs
@@ -56,7 +56,6 @@ mod codex_delegate;
mod collaboration_instructions;
mod compact;
mod compact_remote;
-mod compact_remote_parity;
mod compact_resume_fork;
mod context_annotations;
mod current_time_reminder;
diff --git a/codex-rs/core/tests/suite/reasoning_effort_override.rs b/codex-rs/core/tests/suite/reasoning_effort_override.rs
index 172d420230..3d0a966e9f 100644
--- a/codex-rs/core/tests/suite/reasoning_effort_override.rs
+++ b/codex-rs/core/tests/suite/reasoning_effort_override.rs
@@ -502,28 +502,26 @@ async fn reasoning_effort_override_disabled_on_resume_retires_update_at_compacti
-> anyhow::Result<()> {
skip_if_no_network!(Ok(()));
let server = responses::start_mock_server().await;
- let mut mocks = Vec::new();
- for (id, reply) in [
- ("initial", "initial reply"),
- ("resumed", "resumed reply"),
- ("after", "after compaction reply"),
- ] {
- mocks.push(
- responses::mount_sse_once(
- &server,
- responses::sse(vec![
- responses::ev_assistant_message(id, reply),
- responses::ev_completed(id),
- ]),
- )
- .await,
- );
- }
- let compact = responses::mount_compact_json_once(
+ let reply = |id, text| {
+ responses::sse(vec![
+ responses::ev_assistant_message(id, text),
+ responses::ev_completed(id),
+ ])
+ };
+ let mock = responses::mount_sse_sequence(
&server,
- serde_json::json!({
- "output": [{"type": "compaction", "encrypted_content": "compacted-history"}]
- }),
+ vec![
+ reply("initial", "initial reply"),
+ reply("resumed", "resumed reply"),
+ responses::sse(vec![
+ serde_json::json!({
+ "type": "response.output_item.done",
+ "item": {"type": "compaction", "encrypted_content": "compacted-history"},
+ }),
+ responses::ev_completed("compact"),
+ ]),
+ reply("after", "after compaction reply"),
+ ],
)
.await;
let initial = override_builder().build_with_auto_env(&server).await?;
@@ -536,10 +534,6 @@ async fn reasoning_effort_override_disabled_on_resume_retires_update_at_compacti
.features
.disable(Feature::ReasoningEffortOverride)
.expect("disable overrides");
- config
- .features
- .disable(Feature::RemoteCompactionV2)
- .expect("disable remote compaction v2");
config.model_reasoning_effort = Some(ReasoningEffort::High);
config.chatgpt_base_url = chatgpt_base_url;
})
@@ -553,12 +547,7 @@ async fn reasoning_effort_override_disabled_on_resume_retires_update_at_compacti
.await;
resumed.submit_text_turn("after compaction").await?;
- let requests = [
- mocks[0].single_request(),
- mocks[1].single_request(),
- compact.single_request(),
- mocks[2].single_request(),
- ];
+ let requests = mock.requests();
assert_eq!(
requests
.iter()
@@ -832,125 +821,9 @@ async fn reasoning_effort_override_resume_refreshes_selected_effort(
Ok(())
}
-#[test_case(false; "success")]
-#[test_case(true; "failure")]
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn reasoning_effort_override_remote_v1_compaction_uses_pin(
- fail_compaction: bool,
-) -> anyhow::Result<()> {
- skip_if_no_network!(Ok(()));
- let server = responses::start_mock_server().await;
- let first = responses::mount_sse_once(
- &server,
- responses::sse(vec![responses::ev_completed("first")]),
- )
- .await;
- let after = responses::mount_sse_once(
- &server,
- responses::sse(vec![responses::ev_completed("after")]),
- )
- .await;
- let unchanged = responses::mount_sse_once(
- &server,
- responses::sse(vec![responses::ev_completed("unchanged")]),
- )
- .await;
- let changed = responses::mount_sse_once(
- &server,
- responses::sse(vec![responses::ev_completed("changed")]),
- )
- .await;
- let compact = responses::mount_compact_response_once(
- &server,
- if fail_compaction {
- ResponseTemplate::new(400).set_body_json(serde_json::json!({
- "error": {"code": "invalid_request_error", "message": "compaction failed"}
- }))
- } else {
- ResponseTemplate::new(200).set_body_json(serde_json::json!({
- "output": [{"type": "compaction", "encrypted_content": "compacted-history"}]
- }))
- },
- )
- .await;
- let chatgpt_base_url = format!("{}/backend-api", server.uri());
- let test = override_builder()
- .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
- .with_config(move |config| {
- config.chatgpt_base_url = chatgpt_base_url;
- config
- .features
- .disable(Feature::RemoteCompactionV2)
- .expect("disable remote compaction v2");
- })
- .build_with_auto_env(&server)
- .await?;
- test.submit_text_turn("first").await?;
- submit_thread_settings(
- &test.codex,
- ThreadSettingsOverrides {
- effort: Some(Some(ReasoningEffort::High)),
- ..Default::default()
- },
- )
- .await?;
- test.codex.submit(Op::Compact).await?;
- if fail_compaction {
- wait_for_event(&test.codex, |event| matches!(event, EventMsg::Error(_))).await;
- }
- wait_for_event(&test.codex, |event| {
- matches!(event, EventMsg::TurnComplete(_))
- })
- .await;
- test.submit_text_turn("after compaction").await?;
- test.submit_text_turn("unchanged effort").await?;
- submit_thread_settings(
- &test.codex,
- ThreadSettingsOverrides {
- effort: Some(Some(ReasoningEffort::Low)),
- ..Default::default()
- },
- )
- .await?;
- test.submit_text_turn("changed effort").await?;
- let medium = effort_update(ReasoningEffort::Medium);
- let after_updates = if fail_compaction {
- vec![medium.clone(), effort_update(ReasoningEffort::High)]
- } else {
- Vec::new()
- };
- let mut changed_updates = after_updates.clone();
- changed_updates.push(effort_update(ReasoningEffort::Low));
- let after_effort = Value::from(if fail_compaction { "medium" } else { "high" });
- assert_eq!(
- [
- first.single_request(),
- compact.single_request(),
- after.single_request(),
- unchanged.single_request(),
- changed.single_request(),
- ]
- .map(|request| (
- request.body_json()["reasoning"]["effort"].clone(),
- effort_updates(&request),
- )),
- [
- (Value::from("medium"), vec![medium.clone()]),
- (Value::from("medium"), vec![medium]),
- (after_effort.clone(), after_updates.clone()),
- (after_effort.clone(), after_updates),
- (after_effort, changed_updates),
- ],
- );
- Ok(())
-}
-
-#[test_case(false; "remote v1")]
-#[test_case(true; "remote v2")]
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn reasoning_effort_override_compaction_fallback_uses_each_models_effort(
- remote_v2: bool,
-) -> anyhow::Result<()> {
+async fn reasoning_effort_override_compaction_fallback_uses_each_models_effort()
+-> anyhow::Result<()> {
skip_if_no_network!(Ok(()));
let server = responses::start_mock_server().await;
let first = responses::mount_sse_once(
@@ -969,30 +842,17 @@ async fn reasoning_effort_override_compaction_fallback_uses_each_models_effort(
let failure = ResponseTemplate::new(/*s*/ 400).set_body_json(serde_json::json!({
"error": {"message": "previous model cannot compact this history"}
}));
- let compactions = if remote_v2 {
- responses::mount_response_sequence(
- &server,
- vec![
- failure,
- responses::sse_response(responses::sse(vec![
- serde_json::json!({"type": "response.output_item.done", "item": compaction}),
- responses::ev_completed("fallback"),
- ])),
- ],
- )
- .await
- } else {
- responses::mount_compact_response_sequence(
- &server,
- vec![
- failure,
- ResponseTemplate::new(/*s*/ 200).set_body_json(serde_json::json!({
- "output": [compaction]
- })),
- ],
- )
- .await
- };
+ let compactions = responses::mount_response_sequence(
+ &server,
+ vec![
+ failure,
+ responses::sse_response(responses::sse(vec![
+ serde_json::json!({"type": "response.output_item.done", "item": compaction}),
+ responses::ev_completed("fallback"),
+ ])),
+ ],
+ )
+ .await;
let after = responses::mount_sse_once(
&server,
responses::sse(vec![responses::ev_completed("after")]),
@@ -1012,17 +872,6 @@ async fn reasoning_effort_override_compaction_fallback_uses_each_models_effort(
.with_config(move |config| {
config.chatgpt_base_url = chatgpt_base_url;
config.model_provider.stream_max_retries = Some(0);
- if remote_v2 {
- config
- .features
- .enable(Feature::RemoteCompactionV2)
- .expect("enable remote compaction v2");
- } else {
- config
- .features
- .disable(Feature::RemoteCompactionV2)
- .expect("disable remote compaction v2");
- }
})
.build_with_auto_env(&server)
.await?;
diff --git a/codex-rs/core/tests/suite/responses_lite.rs b/codex-rs/core/tests/suite/responses_lite.rs
index 734104e230..8ffe25e982 100644
--- a/codex-rs/core/tests/suite/responses_lite.rs
+++ b/codex-rs/core/tests/suite/responses_lite.rs
@@ -547,24 +547,30 @@ async fn responses_lite_compact_request_uses_lite_transport_contract() -> Result
skip_if_no_network!(Ok(()));
let server = responses::start_mock_server().await;
- let response_mock = responses::mount_sse_once(
+ let response_mock = responses::mount_sse_sequence(
&server,
- responses::sse(vec![
- responses::ev_response_created("resp-1"),
- responses::ev_completed("resp-1"),
- ]),
+ vec![
+ responses::sse(vec![
+ responses::ev_response_created("resp-1"),
+ responses::ev_completed("resp-1"),
+ ]),
+ responses::sse(vec![
+ serde_json::json!({
+ "type": "response.output_item.done",
+ "item": {
+ "type": "compaction",
+ "encrypted_content": "RESPONSES_LITE_COMPACT_SUMMARY",
+ }
+ }),
+ responses::ev_completed("resp-compact"),
+ ]),
+ ],
)
.await;
- let compact_mock =
- responses::mount_compact_json_once(&server, serde_json::json!({ "output": [] })).await;
- let mut builder = test_codex()
- .with_model_info_override("gpt-5.4", |model_info| {
- model_info.use_responses_lite = true;
- })
- .with_config(|config| {
- let _ = config.features.disable(Feature::RemoteCompactionV2);
- });
+ let mut builder = test_codex().with_model_info_override("gpt-5.4", |model_info| {
+ model_info.use_responses_lite = true;
+ });
let test = builder.build(&server).await?;
test.submit_turn("Compact this conversation").await?;
@@ -574,8 +580,14 @@ async fn responses_lite_compact_request_uses_lite_transport_contract() -> Result
})
.await;
- response_mock.single_request();
- let compact_request = compact_mock.single_request();
+ let requests = response_mock.requests();
+ assert_eq!(requests.len(), 2);
+ let compact_request = &requests[1];
+ assert_eq!(compact_request.path(), "/v1/responses");
+ assert_eq!(
+ compact_request.inputs_of_type("compaction_trigger").len(),
+ 1
+ );
assert_eq!(
compact_request.header(RESPONSES_LITE_HEADER).as_deref(),
Some("true")
diff --git a/codex-rs/core/tests/suite/step_settings_compaction.rs b/codex-rs/core/tests/suite/step_settings_compaction.rs
index 473af1d235..629f115d3d 100644
--- a/codex-rs/core/tests/suite/step_settings_compaction.rs
+++ b/codex-rs/core/tests/suite/step_settings_compaction.rs
@@ -9,12 +9,10 @@ use test_case::test_case;
#[derive(Clone, Copy)]
enum CompactionMode {
Local,
- Remote,
RemoteV2,
}
#[test_case(CompactionMode::Local; "local")]
-#[test_case(CompactionMode::Remote; "remote")]
#[test_case(CompactionMode::RemoteV2; "remote v2")]
#[tokio::test]
async fn compaction_preserves_updated_summary(mode: CompactionMode) -> Result<()> {
@@ -32,23 +30,16 @@ async fn compaction_preserves_updated_summary(mode: CompactionMode) -> Result<()
responses::ev_completed_with_tokens("plan-response", /*total_tokens*/ 330_000),
]),
];
- let compact = match mode {
- CompactionMode::Local => {
- bodies.push(sse(vec![
- responses::ev_assistant_message("summary", "Compacted history"),
- ev_completed("compact"),
- ]));
- None
- }
- CompactionMode::Remote => Some(
- responses::mount_compact_user_history_with_summary_once(&server, "encrypted-summary")
- .await,
- ),
- CompactionMode::RemoteV2 => {
- bodies.push(sse(vec![json!({"type": "response.output_item.done", "item": {"type": "compaction", "encrypted_content": "encrypted-summary"}}), ev_completed("compact")]));
- None
- }
- };
+ bodies.push(match mode {
+ CompactionMode::Local => sse(vec![
+ responses::ev_assistant_message("summary", "Compacted history"),
+ ev_completed("compact"),
+ ]),
+ CompactionMode::RemoteV2 => sse(vec![
+ json!({"type": "response.output_item.done", "item": {"type": "compaction", "encrypted_content": "encrypted-summary"}}),
+ ev_completed("compact"),
+ ]),
+ });
bodies.push(sse_completed("done"));
let responses = mount_sse_sequence(&server, bodies).await;
let test = step_settings_test()
@@ -61,20 +52,9 @@ async fn compaction_preserves_updated_summary(mode: CompactionMode) -> Result<()
.expect("disable token budget");
config.model_provider.name = match mode {
CompactionMode::Local => "Local compaction test",
- CompactionMode::Remote | CompactionMode::RemoteV2 => "OpenAI",
+ CompactionMode::RemoteV2 => "OpenAI",
}
.to_string();
- if matches!(mode, CompactionMode::RemoteV2) {
- config
- .features
- .enable(Feature::RemoteCompactionV2)
- .expect("enable v2");
- } else {
- config
- .features
- .disable(Feature::RemoteCompactionV2)
- .expect("disable v2");
- }
})
.build_with_auto_env(&server)
.await?;
@@ -106,9 +86,6 @@ async fn compaction_preserves_updated_summary(mode: CompactionMode) -> Result<()
],
[json!("concise"), json!("detailed")]
);
- if let Some(compact) = compact {
- compact.single_request();
- }
let rollout =
std::fs::read_to_string(test.session_configured.rollout_path.expect("rollout path"))?;
let items = rollout
diff --git a/codex-rs/core/tests/suite/subagent_notifications.rs b/codex-rs/core/tests/suite/subagent_notifications.rs
index 37c18583c0..2e4a27ddf6 100644
--- a/codex-rs/core/tests/suite/subagent_notifications.rs
+++ b/codex-rs/core/tests/suite/subagent_notifications.rs
@@ -1297,10 +1297,6 @@ async fn grandchild_full_fork_preserves_context_baseline(
config.update_plan_enabled = true;
// Use local compaction so the test controls the replacement history.
config.model_provider.name = "test-provider".to_string();
- config
- .features
- .disable(Feature::RemoteCompactionV2)
- .expect("test config should allow feature update");
config.compact_prompt = Some(COMPACT_PROMPT.to_string());
config.model_auto_compact_token_limit = Some(200_000);
config.model_context_window = Some(1_000_000);
diff --git a/codex-rs/core/tests/suite/token_budget.rs b/codex-rs/core/tests/suite/token_budget.rs
index 3828adf59a..e8add8d490 100644
--- a/codex-rs/core/tests/suite/token_budget.rs
+++ b/codex-rs/core/tests/suite/token_budget.rs
@@ -37,7 +37,6 @@ use core_test_support::responses::ev_completed_with_tokens;
use core_test_support::responses::ev_exec_command_call;
use core_test_support::responses::ev_function_call;
use core_test_support::responses::ev_response_created;
-use core_test_support::responses::mount_compact_json_once;
use core_test_support::responses::mount_sse_once;
use core_test_support::responses::mount_sse_sequence;
use core_test_support::responses::sse;
@@ -1058,8 +1057,6 @@ async fn token_budget_context_uses_new_window_after_compaction(
],
)
.await;
- let compact = mount_compact_json_once(&server, json!({ "output": [] })).await;
-
let mut model_provider = built_in_model_providers(/*openai_base_url*/ None)["openai"].clone();
model_provider.base_url = Some(format!("{}/v1", server.uri()));
model_provider.supports_websockets = false;
@@ -1098,10 +1095,6 @@ async fn token_budget_context_uses_new_window_after_compaction(
let requests = responses.requests();
assert_eq!(requests.len(), 2);
- assert!(
- compact.requests().is_empty(),
- "token budget compaction should not call server-side compaction"
- );
let initial_token_budget = token_budget_contexts(&requests[0]);
assert_eq!(initial_token_budget.len(), 1);
diff --git a/codex-rs/features/src/lib.rs b/codex-rs/features/src/lib.rs
index 5b5206047c..2ce9cb924b 100644
--- a/codex-rs/features/src/lib.rs
+++ b/codex-rs/features/src/lib.rs
@@ -588,7 +588,7 @@ impl Features {
"js_repl_tools_only" => {
continue;
}
- "remote_control" => {
+ "remote_control" | "remote_compaction_v2" => {
continue;
}
"apply_patch_freeform" => {
@@ -1732,8 +1732,8 @@ pub const FEATURES: &[FeatureSpec] = &[
FeatureSpec {
id: Feature::RemoteCompactionV2,
key: "remote_compaction_v2",
- stage: Stage::Stable,
- default_enabled: true,
+ stage: Stage::Removed,
+ default_enabled: false,
},
FeatureSpec {
id: Feature::CompactionImageBudget,