codex: persist multi-agent version metadata

This commit is contained in:
Ahmed Ibrahim
2026-05-29 15:33:17 -07:00
parent a076b21730
commit 88f173945d
37 changed files with 386 additions and 3 deletions
+3
View File
@@ -337,6 +337,9 @@ fn stored_thread_from_state(
.unwrap_or_else(|| "test".to_string()),
model: metadata.and_then(|metadata| metadata.model.clone()),
reasoning_effort: metadata.and_then(|metadata| metadata.reasoning_effort),
multi_agent_version: metadata
.and_then(|metadata| metadata.multi_agent_version)
.unwrap_or(created.metadata.multi_agent_version),
created_at: metadata
.and_then(|metadata| metadata.created_at)
.unwrap_or_else(Utc::now),
@@ -32,6 +32,7 @@ pub(super) async fn create_thread(
params.forked_from_id,
params.source,
params.thread_source,
params.metadata.multi_agent_version,
params.base_instructions,
params.dynamic_tools,
),
@@ -130,6 +130,7 @@ pub(super) fn stored_thread_from_rollout_item(
.unwrap_or_else(|| default_provider.to_string()),
model: None,
reasoning_effort: None,
multi_agent_version: item.multi_agent_version,
created_at,
updated_at,
archived_at,
+94
View File
@@ -296,8 +296,11 @@ mod tests {
use codex_protocol::ThreadId;
use codex_protocol::models::BaseInstructions;
use codex_protocol::openai_models::MultiAgentVersion;
use codex_protocol::protocol::EventMsg;
use codex_protocol::protocol::RolloutItem;
use codex_protocol::protocol::SessionMeta;
use codex_protocol::protocol::SessionMetaLine;
use codex_protocol::protocol::SessionSource;
use codex_protocol::protocol::ThreadMemoryMode;
use codex_protocol::protocol::UserMessageEvent;
@@ -360,6 +363,93 @@ mod tests {
);
}
#[tokio::test]
async fn live_thread_persists_multi_agent_version_in_rollout_and_sqlite() {
let home = TempDir::new().expect("temp dir");
let config = test_config(home.path());
let runtime = codex_state::StateRuntime::init(
config.sqlite_home.clone(),
config.default_model_provider_id.clone(),
)
.await
.expect("state db should initialize");
let store = Arc::new(LocalThreadStore::new(config, Some(runtime.clone())));
let thread_id = ThreadId::default();
let live_thread = LiveThread::create(store.clone(), create_thread_params(thread_id))
.await
.expect("create live thread");
live_thread
.append_items(&[user_message_item("persist selector")])
.await
.expect("append live item");
live_thread
.append_items(&[RolloutItem::SessionMeta(SessionMetaLine {
meta: SessionMeta {
id: thread_id,
source: SessionSource::Exec,
multi_agent_version: Some(MultiAgentVersion::V2),
..Default::default()
},
git: None,
})])
.await
.expect("append selector update");
live_thread.flush().await.expect("flush live thread");
let rollout_path = store
.live_rollout_path(thread_id)
.await
.expect("load rollout path");
let metadata = runtime
.get_thread(thread_id)
.await
.expect("sqlite metadata read")
.expect("sqlite metadata");
let stored_thread = store
.read_thread(ReadThreadParams {
thread_id,
include_archived: false,
include_history: false,
})
.await
.expect("stored thread read");
let (items, _, _) = RolloutRecorder::load_rollout_items(rollout_path.as_path())
.await
.expect("load rollout items");
let persisted_versions = items
.iter()
.filter_map(|item| match item {
RolloutItem::SessionMeta(meta_line) => Some(meta_line.meta.multi_agent_version),
_ => None,
})
.collect::<Vec<_>>();
let jsonl_only_thread =
LocalThreadStore::new(test_config(home.path()), /*state_db*/ None)
.read_thread_by_rollout_path(
rollout_path,
/*include_archived*/ false,
/*include_history*/ true,
)
.await
.expect("jsonl-only stored thread read");
assert_eq!(
(
persisted_versions,
metadata.multi_agent_version,
stored_thread.multi_agent_version,
jsonl_only_thread.multi_agent_version
),
(
vec![None, Some(MultiAgentVersion::V2)],
Some(MultiAgentVersion::V2),
Some(MultiAgentVersion::V2),
Some(MultiAgentVersion::V2)
)
);
}
#[tokio::test]
async fn raw_append_items_does_not_update_sqlite_metadata() {
// This pins the ThreadStore contract: raw appends are history-only. Callers that need
@@ -537,6 +627,7 @@ mod tests {
metadata: ThreadPersistenceMetadata {
cwd: Some(home.path().to_path_buf()),
model_provider: "different-provider".to_string(),
multi_agent_version: None,
memory_mode: ThreadMemoryMode::Enabled,
},
event_persistence_mode: ThreadEventPersistenceMode::Limited,
@@ -592,6 +683,7 @@ mod tests {
metadata: ThreadPersistenceMetadata {
cwd: Some(home.path().to_path_buf()),
model_provider: "different-provider".to_string(),
multi_agent_version: None,
memory_mode: ThreadMemoryMode::Enabled,
},
event_persistence_mode: ThreadEventPersistenceMode::Limited,
@@ -806,6 +898,7 @@ mod tests {
metadata: ThreadPersistenceMetadata {
cwd: None,
model_provider: "test-provider".to_string(),
multi_agent_version: None,
memory_mode: ThreadMemoryMode::Enabled,
},
event_persistence_mode: ThreadEventPersistenceMode::Limited,
@@ -1036,6 +1129,7 @@ mod tests {
ThreadPersistenceMetadata {
cwd: Some(std::env::current_dir().expect("cwd")),
model_provider: "test-provider".to_string(),
multi_agent_version: None,
memory_mode: ThreadMemoryMode::Enabled,
}
}
@@ -2,6 +2,7 @@ use chrono::DateTime;
use chrono::Utc;
use codex_protocol::models::PermissionProfile;
use codex_protocol::protocol::AskForApproval;
use codex_protocol::protocol::RolloutItem;
use codex_protocol::protocol::SessionMetaLine;
use codex_protocol::protocol::SessionSource;
use codex_rollout::RolloutRecorder;
@@ -59,6 +60,7 @@ pub(super) async fn read_thread(
rollout_thread.name = thread.name;
}
rollout_thread.git_info = thread.git_info;
rollout_thread.multi_agent_version = thread.multi_agent_version;
rollout_thread.permission_profile = permission_profile_from_metadata_value(
&metadata_sandbox_policy,
rollout_thread.cwd.as_path(),
@@ -129,6 +131,9 @@ pub(super) async fn read_thread_by_rollout_path(
metadata.git_branch.or(fallback_branch),
metadata.git_origin_url.or(fallback_origin_url),
);
if metadata.multi_agent_version.is_some() {
thread.multi_agent_version = metadata.multi_agent_version;
}
}
attach_history_if_requested(&mut thread, include_history).await?;
Ok(thread)
@@ -162,6 +167,14 @@ async fn attach_history_if_requested(
});
};
let items = load_history_items(&path).await?;
if let Some(multi_agent_version) = items.iter().rev().find_map(|item| match item {
RolloutItem::SessionMeta(meta_line) if meta_line.meta.id == thread_id => {
Some(meta_line.meta.multi_agent_version)
}
_ => None,
}) {
thread.multi_agent_version = multi_agent_version;
}
thread.history = Some(StoredThreadHistory { thread_id, items });
Ok(())
}
@@ -287,6 +300,11 @@ async fn stored_thread_from_sqlite_metadata(
.ok()
.map(|meta_line| meta_line.meta);
let forked_from_id = session_meta.as_ref().and_then(|meta| meta.forked_from_id);
let multi_agent_version = metadata.multi_agent_version.or_else(|| {
session_meta
.as_ref()
.and_then(|meta| meta.multi_agent_version)
});
let preview = metadata
.preview
.clone()
@@ -307,6 +325,7 @@ async fn stored_thread_from_sqlite_metadata(
},
model: metadata.model,
reasoning_effort: metadata.reasoning_effort,
multi_agent_version,
created_at: metadata.created_at,
updated_at: metadata.updated_at,
archived_at: metadata.archived_at,
@@ -370,6 +389,7 @@ fn stored_thread_from_meta_line(
.unwrap_or_else(|| store.config.default_model_provider_id.clone()),
model: None,
reasoning_effort: None,
multi_agent_version: meta_line.meta.multi_agent_version,
created_at,
updated_at,
archived_at: archived.then_some(updated_at),
@@ -213,6 +213,7 @@ async fn apply_metadata_update(
patch.source.clone().unwrap_or(SessionSource::Unknown),
);
builder.model_provider = patch.model_provider.clone();
builder.multi_agent_version = patch.multi_agent_version.flatten();
builder.thread_source = patch.thread_source.flatten();
builder.agent_nickname = patch.agent_nickname.clone().flatten();
builder.agent_role = patch.agent_role.clone().flatten();
@@ -246,6 +247,9 @@ async fn apply_metadata_update(
if let Some(reasoning_effort) = patch.reasoning_effort {
metadata.reasoning_effort = Some(reasoning_effort);
}
if let Some(multi_agent_version) = patch.multi_agent_version {
metadata.multi_agent_version = multi_agent_version;
}
if let Some(created_at) = patch.created_at {
metadata.created_at = created_at;
}
@@ -374,6 +378,7 @@ fn has_observed_metadata_facts(patch: &ThreadMetadataPatch) -> bool {
|| patch.model_provider.is_some()
|| patch.model.is_some()
|| patch.reasoning_effort.is_some()
|| patch.multi_agent_version.is_some()
|| patch.created_at.is_some()
|| patch.source.is_some()
|| patch.thread_source.is_some()
@@ -1615,6 +1620,7 @@ mod tests {
ThreadPersistenceMetadata {
cwd: Some(std::env::current_dir().expect("cwd")),
model_provider: "test-provider".to_string(),
multi_agent_version: None,
memory_mode: ThreadMemoryMode::Enabled,
}
}
@@ -63,6 +63,7 @@ impl ThreadMetadataSync {
};
let update = ThreadMetadataPatch {
model_provider: Some(params.metadata.model_provider.clone()),
multi_agent_version: Some(params.metadata.multi_agent_version),
created_at: Some(created_at),
updated_at: Some(created_at),
source: Some(params.source.clone()),
@@ -178,7 +179,10 @@ impl ThreadMetadataSync {
self.observe_items_with_update(
items,
ThreadMetadataPatch {
updated_at: Some(Utc::now()),
updated_at: items
.iter()
.any(|item| !matches!(item, RolloutItem::SessionMeta(_)))
.then(Utc::now),
..Default::default()
},
)
@@ -205,6 +209,7 @@ impl ThreadMetadataSync {
update.agent_nickname = Some(meta_line.meta.agent_nickname.clone());
update.agent_role = Some(meta_line.meta.agent_role.clone());
update.agent_path = Some(meta_line.meta.agent_path.clone());
update.multi_agent_version = Some(meta_line.meta.multi_agent_version);
if let Some(model_provider) = meta_line.meta.model_provider.clone()
&& !model_provider.is_empty()
{
@@ -345,6 +350,7 @@ fn update_has_metadata_facts(update: &ThreadMetadataPatch) -> bool {
|| update.model_provider.is_some()
|| update.model.is_some()
|| update.reasoning_effort.is_some()
|| update.multi_agent_version.is_some()
|| update.created_at.is_some()
|| update.source.is_some()
|| update.thread_source.is_some()
@@ -371,6 +377,7 @@ fn git_info_patch_from_observation(git_info: GitInfo) -> GitInfoPatch {
#[cfg(test)]
mod tests {
use codex_protocol::openai_models::MultiAgentVersion;
use codex_protocol::protocol::CompactedItem;
use codex_protocol::protocol::SessionMeta;
use codex_protocol::protocol::SessionMetaLine;
@@ -494,6 +501,23 @@ mod tests {
);
}
#[test]
fn session_metadata_only_append_does_not_touch_updated_at() {
let thread_id = ThreadId::new();
let mut sync = ThreadMetadataSync::for_resume(&resume_params(thread_id, Vec::new()));
let mut session_meta = session_meta(thread_id);
session_meta.meta.multi_agent_version = Some(MultiAgentVersion::V2);
let update = sync
.observe_appended_items(&[RolloutItem::SessionMeta(session_meta)])
.expect("session metadata should update selector");
assert_eq!(
(update.patch.multi_agent_version, update.patch.updated_at,),
(Some(Some(MultiAgentVersion::V2)), None)
);
}
#[test]
fn resume_history_waits_for_append_before_flushing_metadata() {
let thread_id = ThreadId::new();
@@ -527,6 +551,7 @@ mod tests {
metadata: ThreadPersistenceMetadata {
cwd: None,
model_provider: "test-provider".to_string(),
multi_agent_version: None,
memory_mode: ThreadMemoryMode::Enabled,
},
event_persistence_mode: ThreadEventPersistenceMode::Limited,
+16
View File
@@ -6,6 +6,7 @@ use codex_protocol::ThreadId;
use codex_protocol::dynamic_tools::DynamicToolSpec;
use codex_protocol::models::BaseInstructions;
use codex_protocol::models::PermissionProfile;
use codex_protocol::openai_models::MultiAgentVersion;
use codex_protocol::openai_models::ReasoningEffort;
use codex_protocol::protocol::AskForApproval;
use codex_protocol::protocol::GitInfo;
@@ -61,6 +62,8 @@ pub struct ThreadPersistenceMetadata {
pub cwd: Option<PathBuf>,
/// Model provider associated with the thread.
pub model_provider: String,
/// Thread-scoped multi-agent runtime selector.
pub multi_agent_version: Option<MultiAgentVersion>,
/// Memory mode associated with the live thread.
pub memory_mode: MemoryMode,
}
@@ -372,6 +375,8 @@ pub struct StoredThread {
pub model: Option<String>,
/// Latest observed reasoning effort, if known.
pub reasoning_effort: Option<ReasoningEffort>,
/// Thread-scoped multi-agent runtime selector.
pub multi_agent_version: Option<MultiAgentVersion>,
/// Thread creation timestamp.
pub created_at: DateTime<Utc>,
/// Thread last-update timestamp.
@@ -479,6 +484,13 @@ pub struct ThreadMetadataPatch {
pub model: Option<String>,
/// Latest observed reasoning effort.
pub reasoning_effort: Option<ReasoningEffort>,
/// Thread-scoped multi-agent runtime selector.
#[serde(
default,
skip_serializing_if = "Option::is_none",
with = "optional_option"
)]
pub multi_agent_version: ClearableField<MultiAgentVersion>,
/// Creation timestamp when known.
pub created_at: Option<DateTime<Utc>>,
/// Last update timestamp for this metadata observation.
@@ -559,6 +571,9 @@ impl ThreadMetadataPatch {
if next.reasoning_effort.is_some() {
self.reasoning_effort = next.reasoning_effort;
}
if next.multi_agent_version.is_some() {
self.multi_agent_version = next.multi_agent_version;
}
if next.created_at.is_some() {
self.created_at = next.created_at;
}
@@ -616,6 +631,7 @@ impl ThreadMetadataPatch {
&& self.model_provider.is_none()
&& self.model.is_none()
&& self.reasoning_effort.is_none()
&& self.multi_agent_version.is_none()
&& self.created_at.is_none()
&& self.updated_at.is_none()
&& self.source.is_none()