Lightweight coding agent that runs in your terminal
Rust
Preserve the resolved multi-agent version when reverting threads (#43000)
jifa7a4321593c7
diff --git a/codex-rs/app-server/README.md b/codex-rs/app-server/README.mdindex ddec1eb88d..13468680e7 100644--- a/codex-rs/app-server/README.md+++ b/codex-rs/app-server/README.md@@ -227,7 +227,7 @@ Example with notification opt-out:- `thread/backgroundTerminals/list` — list running background terminals for a loaded thread (experimental; requires `capabilities.experimentalApi`); returns `data` with the running terminal ids.- `thread/backgroundTerminals/terminate` — terminate one running background terminal by app-server `processId` (experimental; requires `capabilities.experimentalApi`); returns whether a process was terminated.- `thread/rollback` — deprecated and will be removed soon. Drop the last N turns from the agent’s in-memory context and persist a rollback marker in the rollout so future resumes see the pruned history; returns the updated `thread` (with `turns` populated) on success. Paginated threads do not support rollback. Parent-owned Multi-Agent V2 subagents reject direct rollback requests.-- `thread/revert` — replace a loaded paginated thread's durable history with the prefix strictly before `beforeTurnId` while preserving its thread id. The operation interrupts an active turn if needed, leaves older rollout files immutable, reloads the thread, returns updated thread metadata with empty `turns` plus pagination cursors, and emits `thread/reverted`. It does not revert local file changes. Parent-owned Multi-Agent V2 subagents reject direct revert requests.+- `thread/revert` — replace a loaded paginated thread's durable history with the prefix strictly before `beforeTurnId` while preserving its thread id and resolved multi-agent version across reloads. The operation interrupts an active turn if needed, leaves older rollout files immutable, reloads the thread, returns updated thread metadata with empty `turns` plus pagination cursors, and emits `thread/reverted`. It does not revert local file changes. Parent-owned Multi-Agent V2 subagents reject direct revert requests.- `turn/start` — add user input or a named standalone function-call output to a thread and begin Codex generation; responds with the initial `turn` object and streams `turn/started`, `item/*`, and `turn/completed` notifications. For standalone outputs, provide `toolOutput` with an empty `input` array. Optional `turnTrigger` classifies who or what started a new turn and is sent as `turn_trigger` in Responses request metadata; it is ignored if the request steers an active turn. `clientUserMessageId` is optional; when supplied, the corresponding `userMessage` item echoes it as `clientId`. Experimental `runtimeWorkspaceRoots` supplies the default roots for newly resolved environment selections. Explicit `environments[].runtimeWorkspaceRoots` override that fallback with environment-native absolute paths. Prefer experimental `permissions` profile selection by id for permission overrides; the legacy `sandboxPolicy` field is still accepted but cannot be combined with `permissions`. For `collaborationMode`, `settings.developer_instructions: null` means "use built-in instructions for the selected mode". Deprecated experimental `multiAgentMode` is ignored; Ultra reasoning effort selects proactive behavior. Parent-owned Multi-Agent V2 subagents reject direct turns.- `thread/inject_items` — append raw Responses API items to a loaded thread’s model-visible history without starting a turn; returns `{}` on success. Parent-owned Multi-Agent V2 subagents reject direct item injection.- `turn/settings/update` — experimental; publish a reviewer or model-settings patch to the exact live task identified by `threadId` and `turnId`, regardless of task kind. Model-settings updates require `step_model_switching`; reviewer-only updates do not. Returns `status: "applied"` or `status: "targetUnavailable"`, or a request error if rejected. Future-thread settings and already captured steps are unchanged. Parent-owned Multi-Agent V2 subagents reject direct settings updates.diff --git a/codex-rs/app-server/src/request_processors/thread_processor.rs b/codex-rs/app-server/src/request_processors/thread_processor.rsindex 3c00b8c0de..9e28aef7b2 100644--- a/codex-rs/app-server/src/request_processors/thread_processor.rs+++ b/codex-rs/app-server/src/request_processors/thread_processor.rs@@ -2189,6 +2189,7 @@ impl ThreadRequestProcessor {.revert_thread(codex_thread_store::RevertThreadParams {thread_id,before_turn_id,+ multi_agent_version: thread.multi_agent_version(),}).await.map_err(|err| thread_store_mutation_error("revert", err));diff --git a/codex-rs/app-server/tests/suite/v2/thread_revert.rs b/codex-rs/app-server/tests/suite/v2/thread_revert.rsindex ba61faf83c..8f65fb2bbd 100644--- a/codex-rs/app-server/tests/suite/v2/thread_revert.rs+++ b/codex-rs/app-server/tests/suite/v2/thread_revert.rs@@ -5,6 +5,7 @@ use app_test_support::create_final_assistant_message_sse_response;use app_test_support::create_mock_responses_server_repeating_assistant;use app_test_support::create_mock_responses_server_sequence;use app_test_support::create_request_user_input_sse_response;+use app_test_support::write_models_cache_with_models;use codex_app_server_protocol::AskForApproval;use codex_app_server_protocol::ClientInfo;use codex_app_server_protocol::ClientRequest;@@ -32,14 +33,17 @@ use codex_app_server_protocol::TurnStartParams;use codex_app_server_protocol::TurnStartResponse;use codex_app_server_protocol::TurnStatus;use codex_app_server_protocol::UserInput;+use codex_features::Feature;use codex_protocol::config_types::CollaborationMode;use codex_protocol::config_types::ModeKind;use codex_protocol::config_types::Settings;use codex_protocol::openai_models::ReasoningEffort;use codex_protocol::protocol::EventMsg;+use codex_protocol::protocol::MultiAgentVersion;use codex_rollout::RolloutItem;use codex_rollout::read_session_meta_line;use codex_utils_absolute_path::AbsolutePathBuf;+use core_test_support::load_default_config_for_test;use pretty_assertions::assert_eq;use serde_json::Value;use tempfile::TempDir;@@ -47,6 +51,103 @@ use tokio::time::timeout;const DEFAULT_READ_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(10);+#[test_case::test_case(false; "live_reload")]+#[test_case::test_case(true; "cold_resume")]+#[tokio::test]+async fn thread_revert_preserves_model_selected_multi_agent_version(restart: bool) -> Result<()> {+ let server = create_mock_responses_server_repeating_assistant("Done").await;+ let codex_home = TempDir::new()?;+ MockResponsesConfig::new(&server.uri())+ .disable_feature(Feature::MultiAgentV2)+ .write(codex_home.path())?;+ let config = load_default_config_for_test(&codex_home).await;+ let mut model = codex_core::test_support::construct_model_info_offline("mock-model", &config);+ model.multi_agent_version = Some(MultiAgentVersion::V2);+ write_models_cache_with_models(codex_home.path(), vec![model])?;+ let mut mcp = TestAppServer::builder()+ .with_codex_home(codex_home.path())+ .build()+ .await?;+ initialize_experimental(&mut mcp).await?;+ let ThreadStartResponse { thread, .. } = mcp+ .start_thread(ThreadStartParams {+ history_mode: Some(ThreadHistoryMode::Paginated),+ ..Default::default()+ })+ .await?;+ let completed = mcp+ .start_turn_and_wait_for_completion(TurnStartParams {+ thread_id: thread.id.clone(),+ input: vec![UserInput::Text {+ text: "First message".to_string(),+ text_elements: Vec::new(),+ }],+ ..Default::default()+ })+ .await?;+ let _: ThreadRevertResponse = mcp+ .request(|request_id| ClientRequest::ThreadRevert {+ request_id,+ params: ThreadRevertParams {+ thread_id: thread.id.clone(),+ before_turn_id: completed.turn.id,+ },+ })+ .await?;+ if restart {+ // Restart before another turn can persist a replacement TurnContext.+ mcp.shutdown_gracefully().await?;+ mcp = TestAppServer::builder()+ .with_codex_home(codex_home.path())+ .build()+ .await?;+ initialize_experimental(&mut mcp).await?;+ let _: ThreadResumeResponse = mcp+ .request(|request_id| ClientRequest::ThreadResume {+ request_id,+ params: ThreadResumeParams {+ thread_id: thread.id.clone(),+ exclude_turns: true,+ ..Default::default()+ },+ })+ .await?;+ }+ mcp.start_turn_and_wait_for_completion(TurnStartParams {+ thread_id: thread.id,+ input: vec![UserInput::Text {+ text: "Edited first message".to_string(),+ text_elements: Vec::new(),+ }],+ ..Default::default()+ })+ .await?;++ let requests = server.received_requests().await.expect("response requests");+ let mut multi_agent_namespaces = Vec::new();+ for request in requests+ .iter()+ .filter(|request| request.url.path().ends_with("/responses"))+ {+ let body = request.body_json::<Value>()?;+ multi_agent_namespaces.push(+ body["tools"]+ .as_array()+ .expect("tools")+ .iter()+ .filter_map(|tool| tool["name"].as_str())+ .filter(|name| matches!(*name, "collaboration" | "multi_agent_v1"))+ .map(str::to_owned)+ .collect::<Vec<_>>(),+ );+ }+ assert_eq!(+ multi_agent_namespaces,+ vec![vec!["collaboration"], vec!["collaboration"]]+ );+ Ok(())+}+#[tokio::test]async fn thread_revert_preserves_fork_cutoff_after_cold_resume() -> Result<()> {let server = create_mock_responses_server_repeating_assistant("Done").await;diff --git a/codex-rs/thread-store/src/local/revert_thread.rs b/codex-rs/thread-store/src/local/revert_thread.rsindex 66d47c518d..c96cac26b3 100644--- a/codex-rs/thread-store/src/local/revert_thread.rs+++ b/codex-rs/thread-store/src/local/revert_thread.rs@@ -23,6 +23,7 @@ pub(super) async fn revert(let RevertThreadParams {thread_id,before_turn_id,+ multi_agent_version,} = params;let state_db = store.state_db()@@ -48,7 +49,7 @@ pub(super) async fn revert(.await?.ok_or(ThreadStoreError::ThreadNotFound { thread_id })?;let source_path = current_rollout.path;- let source_meta = codex_rollout::read_session_meta_line(source_path.as_path())+ let mut source_meta = codex_rollout::read_session_meta_line(source_path.as_path()).await.map_err(|err| ThreadStoreError::Internal {message: format!(@@ -106,6 +107,7 @@ pub(super) async fn revert(cutoff.min(history_base.map_or(0, |base| base.end_ordinal_exclusive))});+ source_meta.multi_agent_version = multi_agent_version.or(source_meta.multi_agent_version);let rollout_id = ThreadId::new();let recorder = create_replacement_recorder(store,diff --git a/codex-rs/thread-store/src/local/revert_thread_tests.rs b/codex-rs/thread-store/src/local/revert_thread_tests.rsindex 1bf99b62e0..ebfc64d2db 100644--- a/codex-rs/thread-store/src/local/revert_thread_tests.rs+++ b/codex-rs/thread-store/src/local/revert_thread_tests.rs@@ -1,6 +1,7 @@use codex_protocol::ThreadId;use codex_protocol::models::BaseInstructions;use codex_protocol::protocol::EventMsg;+use codex_protocol::protocol::MultiAgentVersion;use codex_protocol::protocol::SessionSource;use codex_protocol::protocol::ThreadHistoryMode;use codex_protocol::protocol::ThreadMemoryMode;@@ -72,6 +73,7 @@ async fn revert_keeps_thread_id_and_hides_suffix_across_repeated_reverts() {.revert_thread(RevertThreadParams {thread_id,before_turn_id: "turn-2".to_string(),+ multi_agent_version: None,}).await.expect("revert before second turn");@@ -98,6 +100,7 @@ async fn revert_keeps_thread_id_and_hides_suffix_across_repeated_reverts() {.revert_thread(RevertThreadParams {thread_id,before_turn_id: "turn-1".to_string(),+ multi_agent_version: None,}).await.expect("revert before first turn");@@ -134,6 +137,80 @@ async fn revert_keeps_thread_id_and_hides_suffix_across_repeated_reverts() {}}+#[tokio::test]+async fn revert_preserves_resolved_multi_agent_version_in_session_metadata() {+ let home = TempDir::new().expect("temp dir");+ let config = test_config(home.path());+ let state_db = codex_state::StateRuntime::init(+ config.sqlite.clone(),+ config.default_model_provider_id.clone(),+ )+ .await+ .expect("initialize state database");+ let store = LocalThreadStore::new(config, Some(state_db.clone()));++ for version in [+ MultiAgentVersion::V1,+ MultiAgentVersion::V2,+ MultiAgentVersion::Disabled,+ ] {+ let thread_id = ThreadId::new();+ create_paginated_thread(&store, thread_id).await;+ store+ .append_items(AppendThreadItemsParams {+ thread_id,+ items: vec![+ turn_started("turn-1"),+ turn_completed("turn-1"),+ turn_started("turn-2"),+ turn_completed("turn-2"),+ ],+ })+ .await+ .expect("append turns");+ let path = store+ .live_rollout_path(thread_id)+ .await+ .expect("source rollout path");+ store+ .shutdown_thread(thread_id)+ .await+ .expect("close source writer");+ codex_rollout::state_db::reconcile_rollout(+ Some(state_db.as_ref()),+ path.as_path(),+ "test-provider",+ /*builder*/ None,+ &[],+ /*archived_only*/ Some(false),+ /*new_thread_memory_mode*/ None,+ )+ .await;++ // The second revert has no live version to supply and must keep the persisted one.+ for (before_turn_id, multi_agent_version) in [("turn-2", Some(version)), ("turn-1", None)] {+ store+ .revert_thread(RevertThreadParams {+ thread_id,+ before_turn_id: before_turn_id.to_string(),+ multi_agent_version,+ })+ .await+ .expect("revert thread");+ let path = state_db+ .get_thread(thread_id)+ .await+ .expect("read metadata")+ .expect("thread metadata")+ .rollout_path;+ let meta = codex_rollout::read_session_meta_line(&path)+ .await+ .expect("read replacement metadata");+ assert_eq!(meta.meta.multi_agent_version, Some(version));+ }+ }+}+async fn rollout_paths_for_thread(home: &std::path::Path,thread_id: ThreadId,diff --git a/codex-rs/thread-store/src/types.rs b/codex-rs/thread-store/src/types.rsindex 8ada9a5a34..877533a6dd 100644--- a/codex-rs/thread-store/src/types.rs+++ b/codex-rs/thread-store/src/types.rs@@ -207,6 +207,9 @@ pub struct RevertThreadParams {pub thread_id: ThreadId,/// First turn excluded from the retained history.pub before_turn_id: String,+ /// Resolved runtime version to preserve when its turn context is removed.+ /// When absent, keep the version in the existing session metadata.+ pub multi_agent_version: Option<MultiAgentVersion>,}/// Frozen source history and model context for a reference-backed fork.