mirror of
https://github.com/openai/codex.git
synced 2026-11-18 22:20:48 +00:00
Keep authorization evidence local to agent forks (#62314)
## Why A prepared agent fork needs its ancestor's conversation for context. Treating that conversation as the child's own authorization evidence can attribute the ancestor's messages and approvals to the child. ## What changed Allow host-started prepared forks that reference stored history to inherit the root session ID. Keep ancestor messages as conversation context and exclude ancestor authorization evidence when starting or resuming the fork and when reconstructing sender evidence from storage. Preserve the inherited disabled-plugin settings and the child's own authorization evidence. ## Testing Cover prepared forks across startup and resume, including inherited context, plugin settings, and child-local authorization. Verify that live and stored sender evidence both contain only the child's messages. GitOrigin-RevId: 5c5a6547d31fe78dfad3742efb8a41df539173c6
This commit is contained in:
@@ -7,10 +7,13 @@ use crate::context::GuardianSenderMessages;
|
||||
use crate::context_manager::ContextManager;
|
||||
use crate::session::session::Session;
|
||||
use codex_history::RolloutItem;
|
||||
use codex_protocol::SessionId;
|
||||
use codex_protocol::ThreadId;
|
||||
use codex_protocol::models::ResponseItem;
|
||||
use codex_protocol::protocol::ThreadHistoryMode;
|
||||
use codex_thread_store::LoadThreadHistoryParams;
|
||||
use codex_utils_output_truncation::TruncationPolicy;
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
|
||||
use super::LocalAgentRuntime;
|
||||
@@ -90,29 +93,52 @@ impl LocalAgentRuntime {
|
||||
}),
|
||||
)
|
||||
.await;
|
||||
match stored {
|
||||
Ok(Ok(stored)) if stored.thread_id == source_thread_id => {
|
||||
let meta = stored.items.iter().find_map(|item| match item {
|
||||
RolloutItem::SessionMeta(meta) => Some(&meta.meta),
|
||||
_ => None,
|
||||
});
|
||||
meta.filter(|meta| {
|
||||
meta.id == source_thread_id && !meta.source.is_internal()
|
||||
})
|
||||
.map(|meta| {
|
||||
fragment.from_storage = true;
|
||||
ContextManager::reconstruct_rollout(
|
||||
&stored.items,
|
||||
meta.history_mode,
|
||||
ContextManager::new(Session::new_item_id_generator()),
|
||||
// Tool bodies are not sender authorization evidence.
|
||||
TruncationPolicy::Bytes(0),
|
||||
)
|
||||
.retained_context
|
||||
})
|
||||
let capture = || {
|
||||
let stored = stored.ok()?.ok()?;
|
||||
if stored.thread_id != source_thread_id {
|
||||
return None;
|
||||
}
|
||||
Ok(Ok(_)) | Ok(Err(_)) | Err(_) => None,
|
||||
}
|
||||
let RolloutItem::SessionMeta(meta) = stored.items.first()? else {
|
||||
return None;
|
||||
};
|
||||
if meta.meta.id != source_thread_id || meta.meta.source.is_internal() {
|
||||
return None;
|
||||
}
|
||||
let history_mode = meta.meta.history_mode;
|
||||
let referenced_agent_fork = meta.meta.history_base.is_some()
|
||||
&& meta.meta.session_id != SessionId::from(source_thread_id)
|
||||
&& meta.meta.subagent_history_start_ordinal.is_none();
|
||||
let version = if referenced_agent_fork {
|
||||
if history_mode != ThreadHistoryMode::Paginated
|
||||
|| meta.meta.forked_from_id.is_none()
|
||||
{
|
||||
return None;
|
||||
}
|
||||
Some(meta.meta.multi_agent_version?)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let mut history = Arc::new(stored.items);
|
||||
if let Some(version) = version {
|
||||
crate::agent::sanitize_referenced_agent_fork(
|
||||
source_thread_id,
|
||||
&mut history,
|
||||
version,
|
||||
)
|
||||
.ok()?;
|
||||
}
|
||||
let context = ContextManager::reconstruct_rollout(
|
||||
&history,
|
||||
history_mode,
|
||||
ContextManager::new(Session::new_item_id_generator()),
|
||||
// Tool bodies are not sender authorization evidence.
|
||||
TruncationPolicy::Bytes(0),
|
||||
)
|
||||
.retained_context;
|
||||
fragment.from_storage = true;
|
||||
Some(context)
|
||||
};
|
||||
capture()
|
||||
}
|
||||
};
|
||||
if let Some(context) = context {
|
||||
|
||||
@@ -29,6 +29,7 @@ use codex_history::InitialHistory;
|
||||
use codex_history::ResponseItemEnvelope;
|
||||
use codex_history::RolloutItem;
|
||||
use codex_prompts::ResolvedModelMessages;
|
||||
use codex_protocol::SessionId;
|
||||
use codex_protocol::ThreadId;
|
||||
use codex_protocol::error::CodexErr;
|
||||
use codex_protocol::error::Result as CodexResult;
|
||||
@@ -41,6 +42,153 @@ use codex_protocol::protocol::SessionSource;
|
||||
use codex_protocol::protocol::SubAgentSource;
|
||||
use codex_protocol::protocol::ThreadHistoryMode;
|
||||
use codex_thread_store::LoadThreadHistoryParams;
|
||||
use std::sync::Arc;
|
||||
|
||||
fn sanitize_forked_rollout_item(
|
||||
item: &mut RolloutItem,
|
||||
version: MultiAgentVersion,
|
||||
preserve_context_baselines: bool,
|
||||
preserve_fork_prefix: bool,
|
||||
history_mode: ThreadHistoryMode,
|
||||
mut retain_response: impl FnMut(&mut ResponseItemEnvelope) -> bool,
|
||||
) -> bool {
|
||||
if !((preserve_fork_prefix && matches!(item, RolloutItem::ResponseItem(_)))
|
||||
|| keep_forked_rollout_item(item, preserve_context_baselines))
|
||||
|| history_mode == ThreadHistoryMode::Paginated
|
||||
&& matches!(
|
||||
item,
|
||||
RolloutItem::EventMsg(
|
||||
EventMsg::ItemCompleted(_)
|
||||
| EventMsg::TokenCount(_)
|
||||
| EventMsg::ThreadGoalUpdated(_)
|
||||
| EventMsg::ThreadSettingsApplied(_)
|
||||
)
|
||||
)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
let mut retain_envelope = |envelope: &mut ResponseItemEnvelope| {
|
||||
let explicitly_retained = envelope.is_always_retained();
|
||||
if preserve_fork_prefix
|
||||
|| explicitly_retained
|
||||
|| (version == MultiAgentVersion::V2
|
||||
&& matches!(&envelope.item, ResponseItem::Message { role, .. } if role == "user" || role == "assistant"))
|
||||
{
|
||||
envelope
|
||||
.metadata
|
||||
.get_or_insert_default()
|
||||
.inherited_user_message = true;
|
||||
}
|
||||
if let Some(metadata) = &mut envelope.metadata
|
||||
&& (metadata.sender_user_messages.take().is_some()
|
||||
|| !matches!(&envelope.item, ResponseItem::Message { role, .. } if role == "user"))
|
||||
{
|
||||
metadata.user_input_order = None;
|
||||
}
|
||||
preserve_fork_prefix || explicitly_retained || retain_response(envelope)
|
||||
};
|
||||
match item {
|
||||
RolloutItem::ResponseItem(envelope) => retain_envelope(envelope),
|
||||
RolloutItem::Compacted(compacted) => {
|
||||
compacted.latest_token_usage_record = None;
|
||||
if let Some(metadata) = &mut compacted.resume_metadata {
|
||||
metadata.multi_agent_version = Some(version);
|
||||
metadata.turn_attribution = None;
|
||||
if !preserve_context_baselines {
|
||||
metadata.previous_turn_settings = None;
|
||||
}
|
||||
}
|
||||
compacted.guardian_history = None;
|
||||
compacted.retained_context =
|
||||
(version == MultiAgentVersion::V2).then(codex_history::RetainedContext::default);
|
||||
if let Some(history) = &mut compacted.replacement_history {
|
||||
history.retain_mut(&mut retain_envelope);
|
||||
}
|
||||
true
|
||||
}
|
||||
RolloutItem::WorldState(world_state)
|
||||
if version == MultiAgentVersion::V2 || preserve_fork_prefix =>
|
||||
{
|
||||
world_state.state.remove("multi_agent_usage_hint");
|
||||
true
|
||||
}
|
||||
_ => true,
|
||||
}
|
||||
}
|
||||
|
||||
/// Project an ancestor prefix as agent context without changing referenced source history.
|
||||
pub(crate) fn sanitize_agent_fork_prefix(
|
||||
items: &mut Vec<RolloutItem>,
|
||||
prefix_len: usize,
|
||||
version: MultiAgentVersion,
|
||||
) -> usize {
|
||||
let prefix_len = prefix_len.min(items.len());
|
||||
let removed = items
|
||||
.extract_if(..prefix_len, |item| {
|
||||
!sanitize_forked_rollout_item(
|
||||
item,
|
||||
version,
|
||||
/*preserve_context_baselines*/ true,
|
||||
/*preserve_fork_prefix*/ true,
|
||||
ThreadHistoryMode::Paginated,
|
||||
|_| true,
|
||||
)
|
||||
})
|
||||
.count();
|
||||
prefix_len - removed
|
||||
}
|
||||
|
||||
/// Project immutable ancestor ranges when reading a referenced agent fork.
|
||||
pub(crate) fn sanitize_referenced_agent_fork(
|
||||
thread_id: ThreadId,
|
||||
history: &mut Arc<Vec<RolloutItem>>,
|
||||
version: MultiAgentVersion,
|
||||
) -> CodexResult<()> {
|
||||
let Some(RolloutItem::SessionMeta(meta)) = history.first() else {
|
||||
return Ok(());
|
||||
};
|
||||
let Some(history_base) = meta.meta.history_base else {
|
||||
return Ok(());
|
||||
};
|
||||
if meta.meta.id != thread_id
|
||||
|| meta.meta.forked_from_id.is_none()
|
||||
|| meta.meta.subagent_history_start_ordinal.is_some()
|
||||
|| meta.meta.session_id == SessionId::from(thread_id)
|
||||
{
|
||||
return Ok(());
|
||||
}
|
||||
let boundary = history
|
||||
.iter()
|
||||
.position(|item| match item {
|
||||
RolloutItem::EventMsg(EventMsg::ThreadSettingsApplied(event)) => {
|
||||
event.thread_id == Some(thread_id)
|
||||
}
|
||||
// A bounded context scan can begin at a child-owned compaction, omitting
|
||||
// the original startup event. Its catalog snapshot identifies its owner.
|
||||
RolloutItem::Compacted(checkpoint) => checkpoint
|
||||
.resume_metadata
|
||||
.as_ref()
|
||||
.and_then(|metadata| metadata.dynamic_tools.as_ref())
|
||||
.is_some_and(|snapshot| snapshot.thread_id == thread_id),
|
||||
_ => false,
|
||||
})
|
||||
.or_else(|| {
|
||||
// Revert can truncate before the child's startup event. If the
|
||||
// physical base ends inside the logical parent prefix, all surviving
|
||||
// context is inherited.
|
||||
meta.meta
|
||||
.forked_from_ordinal_exclusive
|
||||
.filter(|cutoff| history_base.end_ordinal_exclusive <= *cutoff)
|
||||
.map(|_| history.len())
|
||||
})
|
||||
.ok_or_else(|| {
|
||||
CodexErr::InvalidRequest(
|
||||
"referenced agent fork history is missing its child boundary".to_string(),
|
||||
)
|
||||
})?;
|
||||
sanitize_agent_fork_prefix(Arc::make_mut(history), boundary, version);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
impl LocalAgentRuntime {
|
||||
pub(crate) async fn retained_items_for_fresh_child(
|
||||
@@ -302,28 +450,6 @@ pub(super) async fn prepare_forked_history(
|
||||
forked_rollout_items = items;
|
||||
}
|
||||
let retain_forked_item = |envelope: &mut ResponseItemEnvelope, replaced: &mut bool| {
|
||||
let explicitly_retained = envelope.is_always_retained();
|
||||
if explicitly_retained
|
||||
|| (multi_agent_version == MultiAgentVersion::V2
|
||||
&& (preserve_fork_prefix
|
||||
|| matches!(&envelope.item, ResponseItem::Message { role, .. } if role == "user" || role == "assistant")))
|
||||
{
|
||||
// Resume must not recapture copied parent messages as local authorization.
|
||||
envelope
|
||||
.metadata
|
||||
.get_or_insert_default()
|
||||
.inherited_user_message = true;
|
||||
}
|
||||
if let Some(metadata) = &mut envelope.metadata
|
||||
&& (metadata.sender_user_messages.take().is_some()
|
||||
|| !matches!(&envelope.item, ResponseItem::Message { role, .. } if role == "user"))
|
||||
{
|
||||
// Assistant and tool positions belong to the parent counter, not the child.
|
||||
metadata.user_input_order = None;
|
||||
}
|
||||
if preserve_fork_prefix || explicitly_retained {
|
||||
return true;
|
||||
}
|
||||
let response_item = &mut envelope.item;
|
||||
// Tool declarations and their comparison baseline must survive or be rebuilt together.
|
||||
// Apply this to both standalone items and compaction replacement histories.
|
||||
@@ -389,74 +515,18 @@ pub(super) async fn prepare_forked_history(
|
||||
true
|
||||
};
|
||||
forked_rollout_items.retain_mut(|item| {
|
||||
let keep = (preserve_fork_prefix && matches!(item, RolloutItem::ResponseItem(_)))
|
||||
|| keep_forked_rollout_item(item, preserve_context_baselines);
|
||||
if !keep
|
||||
|| destination_history_mode == Some(ThreadHistoryMode::Paginated)
|
||||
&& matches!(
|
||||
&*item,
|
||||
RolloutItem::EventMsg(
|
||||
EventMsg::ItemCompleted(_)
|
||||
| EventMsg::TokenCount(_)
|
||||
| EventMsg::ThreadGoalUpdated(_)
|
||||
| EventMsg::ThreadSettingsApplied(_),
|
||||
)
|
||||
)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
match item {
|
||||
RolloutItem::ResponseItem(response_item) => {
|
||||
retain_forked_item(response_item, &mut replaced_parent_developer_instructions)
|
||||
}
|
||||
RolloutItem::Compacted(compacted) => {
|
||||
// This compaction becomes part of the subagent's initial history. Rewrite its
|
||||
// metadata to describe the child rather than the parent.
|
||||
compacted.latest_token_usage_record = None;
|
||||
if let Some(resume_metadata) = &mut compacted.resume_metadata {
|
||||
resume_metadata.multi_agent_version = Some(multi_agent_version);
|
||||
resume_metadata.turn_attribution = None;
|
||||
if !preserve_context_baselines {
|
||||
resume_metadata.previous_turn_settings = None;
|
||||
}
|
||||
}
|
||||
// Parent-local review evidence must not become the child's authorization.
|
||||
// Root user authorization is collected separately by the host.
|
||||
compacted.guardian_history = None;
|
||||
// Only V2 fetches root authorization live. Its local scope starts known-empty;
|
||||
// V1 must remain incomplete when inherited authorization has been stripped.
|
||||
compacted.retained_context = (multi_agent_version == MultiAgentVersion::V2)
|
||||
.then(codex_history::RetainedContext::default);
|
||||
if let Some(replacement_history) = compacted.replacement_history.as_mut() {
|
||||
// Matches before this checkpoint cannot survive its replacement history.
|
||||
replaced_parent_developer_instructions = false;
|
||||
replacement_history.retain_mut(|response_item| {
|
||||
retain_forked_item(
|
||||
response_item,
|
||||
&mut replaced_parent_developer_instructions,
|
||||
)
|
||||
});
|
||||
}
|
||||
true
|
||||
}
|
||||
RolloutItem::WorldState(world_state) => {
|
||||
if multi_agent_version == MultiAgentVersion::V2 {
|
||||
world_state.state.remove("multi_agent_usage_hint");
|
||||
}
|
||||
true
|
||||
}
|
||||
RolloutItem::RealtimeItem(_) => false,
|
||||
RolloutItem::DynamicToolsUpdated { .. }
|
||||
| RolloutItem::EventMsg(_)
|
||||
| RolloutItem::SessionMeta(_)
|
||||
| RolloutItem::TurnContext(_)
|
||||
| RolloutItem::InterAgentCommunication(_)
|
||||
| RolloutItem::InterAgentCommunicationMetadata { .. } => true,
|
||||
RolloutItem::RetainedContext(_)
|
||||
| RolloutItem::TokenUsageRecord(_)
|
||||
| RolloutItem::SecurityRiskScore(_) => false,
|
||||
if matches!(item, RolloutItem::Compacted(checkpoint) if checkpoint.replacement_history.is_some()) {
|
||||
// Matches before this checkpoint cannot survive its replacement history.
|
||||
replaced_parent_developer_instructions = false;
|
||||
}
|
||||
sanitize_forked_rollout_item(
|
||||
item,
|
||||
multi_agent_version,
|
||||
preserve_context_baselines,
|
||||
preserve_fork_prefix,
|
||||
parent_history_mode,
|
||||
|response| retain_forked_item(response, &mut replaced_parent_developer_instructions),
|
||||
)
|
||||
});
|
||||
if preserve_fork_prefix {
|
||||
forked_rollout_items.push(RolloutItem::ResponseItem(
|
||||
|
||||
@@ -33,7 +33,7 @@ use std::sync::Arc;
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct RestrictRootCapabilities;
|
||||
|
||||
/// The root's session ID, supplied by a trusted host when starting a new or forked child.
|
||||
/// The root's session ID, supplied by a trusted host for a fresh child or a prepared fork.
|
||||
///
|
||||
/// Insert this into the thread's startup [`codex_extension_api::ExtensionDataInit`].
|
||||
/// The child keeps its own distinct thread ID. Resumed threads take their session
|
||||
|
||||
@@ -12,6 +12,8 @@ pub(crate) mod types;
|
||||
|
||||
pub(crate) use codex_protocol::protocol::AgentStatus;
|
||||
pub(crate) use control::LocalAgentControl;
|
||||
pub(crate) use history::sanitize_agent_fork_prefix;
|
||||
pub(crate) use history::sanitize_referenced_agent_fork;
|
||||
pub(crate) use registry::exceeds_thread_spawn_depth_limit;
|
||||
pub(crate) use registry::next_thread_spawn_depth;
|
||||
pub(crate) use status::agent_status_from_event;
|
||||
|
||||
@@ -1293,11 +1293,18 @@ impl Session {
|
||||
})?;
|
||||
// Keep the large initialization future out of callers' stack frames.
|
||||
let session_result: anyhow::Result<Arc<Self>> = Box::pin(async {
|
||||
if let InitialHistory::Resumed(resumed) = &mut initial_history
|
||||
&& let Some(history) = resume_context
|
||||
{
|
||||
resumed.history = history;
|
||||
resumed.history_revision = None;
|
||||
if let InitialHistory::Resumed(resumed) = &mut initial_history {
|
||||
if let Some(history) = resume_context {
|
||||
resumed.history = history;
|
||||
resumed.history_revision = None;
|
||||
}
|
||||
let version = initial_multi_agent_version
|
||||
.unwrap_or_else(|| config.multi_agent_version_from_features());
|
||||
crate::agent::sanitize_referenced_agent_fork(
|
||||
resumed.conversation_id,
|
||||
&mut resumed.history,
|
||||
version,
|
||||
)?;
|
||||
}
|
||||
let super::model_ids::InitialModelIds {
|
||||
item_id_generator,
|
||||
|
||||
@@ -1874,6 +1874,7 @@ impl ThreadManager {
|
||||
}
|
||||
|
||||
/// Fork an existing thread from already-loaded store history.
|
||||
/// For an inherited session ID, use [`Self::fork_prepared_thread`] instead.
|
||||
pub async fn fork_thread_from_history<S>(
|
||||
&self,
|
||||
snapshot: S,
|
||||
@@ -1932,7 +1933,7 @@ impl ThreadManager {
|
||||
let ForkHistory {
|
||||
snapshot,
|
||||
initial_history: history,
|
||||
persistence: fork_persistence,
|
||||
persistence: mut fork_persistence,
|
||||
} = fork_history;
|
||||
// `forked_from_id()` describes this history's existing lineage. When
|
||||
// forking a resumed thread, the child copies the resumed thread itself.
|
||||
@@ -1970,6 +1971,29 @@ impl ThreadManager {
|
||||
multi_agent_version,
|
||||
);
|
||||
options.initial_history = fork_history_from_snapshot(snapshot, history, interrupted_marker);
|
||||
if options
|
||||
.thread_extension_init
|
||||
.get::<InheritedSessionId>()
|
||||
.is_some()
|
||||
&& let ForkPersistence::Referenced {
|
||||
inherited_item_count,
|
||||
..
|
||||
} = &mut fork_persistence
|
||||
&& let InitialHistory::Forked(items) = &mut options.initial_history
|
||||
{
|
||||
if options.disabled_plugin_ids.is_none()
|
||||
&& let Some(thread_id) = source_thread_id
|
||||
{
|
||||
options.disabled_plugin_ids =
|
||||
codex_history::latest_disabled_plugin_ids(items, thread_id)
|
||||
.map(<[String]>::to_vec);
|
||||
}
|
||||
*inherited_item_count = crate::agent::sanitize_agent_fork_prefix(
|
||||
items,
|
||||
*inherited_item_count,
|
||||
multi_agent_version,
|
||||
);
|
||||
}
|
||||
let agent_control = self.agent_control_for_config(&options.config);
|
||||
let mut request =
|
||||
ThreadSpawnRequest::new(options, Arc::clone(&self.state.auth_manager), agent_control);
|
||||
@@ -2623,13 +2647,18 @@ impl ThreadManagerState {
|
||||
let inherited_environments = captured_environments.or(inherited_environments);
|
||||
let session_source = session_source.unwrap_or_else(|| self.session_source.clone());
|
||||
if thread_extension_init.get::<InheritedSessionId>().is_some()
|
||||
&& (!matches!(
|
||||
&initial_history,
|
||||
InitialHistory::New | InitialHistory::Forked(_)
|
||||
) || session_source.is_non_root_agent())
|
||||
&& (session_source.is_non_root_agent()
|
||||
|| !matches!(
|
||||
(&initial_history, &fork_persistence),
|
||||
(InitialHistory::New, _)
|
||||
| (
|
||||
InitialHistory::Forked(_),
|
||||
ForkPersistence::Referenced { .. }
|
||||
)
|
||||
))
|
||||
{
|
||||
return Err(CodexErr::InvalidRequest(
|
||||
"an inherited agent session ID requires a new or forked thread started directly by the host"
|
||||
"an inherited agent session ID requires a new thread or a prepared fork started directly by the host"
|
||||
.to_string(),
|
||||
));
|
||||
}
|
||||
|
||||
@@ -21,6 +21,7 @@ use codex_core::GuardianRootSnapshot;
|
||||
use codex_core::InheritedSessionId;
|
||||
use codex_core::LiveAgent;
|
||||
use codex_core::PendingAgentMessage;
|
||||
use codex_core::RestrictRootCapabilities;
|
||||
use codex_core::RolloutBudgetReminder;
|
||||
use codex_core::SendRequest;
|
||||
use codex_core::SpawnRequest;
|
||||
@@ -30,6 +31,7 @@ use codex_core::TurnInput;
|
||||
use codex_core::TurnInputRequest;
|
||||
use codex_core::TurnInputSubmission;
|
||||
use codex_core::TurnStartOptions;
|
||||
use codex_core::compact::content_items_to_text;
|
||||
use codex_core::config::Config;
|
||||
use codex_extension_api::ExtensionFuture;
|
||||
use codex_extension_api::ExtensionRegistryBuilder;
|
||||
@@ -39,9 +41,17 @@ use codex_extension_api::ThreadStopInput;
|
||||
use codex_extension_api::TurnLifecycleContributor;
|
||||
use codex_extension_api::TurnStopInput;
|
||||
use codex_features::Feature;
|
||||
use codex_history::CodexHarnessMetadata;
|
||||
use codex_history::InitialHistory;
|
||||
use codex_history::ResponseItemEnvelope;
|
||||
use codex_history::ResumedHistory;
|
||||
use codex_history::RetainedContextEntry;
|
||||
use codex_history::RetainedContextEvent;
|
||||
use codex_history::RetainedContextOrder;
|
||||
use codex_history::RolloutItem;
|
||||
use codex_history::SenderUserMessages;
|
||||
use codex_history::VerifiedAnswer;
|
||||
use codex_history::VerifiedQuestionAnswer;
|
||||
use codex_message_board::PostMetadata;
|
||||
use codex_protocol::AgentPath;
|
||||
use codex_protocol::SessionId;
|
||||
@@ -49,6 +59,7 @@ use codex_protocol::ThreadId;
|
||||
use codex_protocol::error::CodexErr;
|
||||
use codex_protocol::error::CodexErrorDetails;
|
||||
use codex_protocol::error::Result as CodexResult;
|
||||
use codex_protocol::models::ResponseItem;
|
||||
use codex_protocol::protocol::AgentStatus;
|
||||
use codex_protocol::protocol::InterAgentCommunication;
|
||||
use codex_protocol::protocol::MultiAgentVersion;
|
||||
@@ -56,6 +67,7 @@ use codex_protocol::protocol::Op;
|
||||
use codex_protocol::protocol::SessionSource;
|
||||
use codex_protocol::protocol::SubAgentSource;
|
||||
use codex_protocol::protocol::ThreadHistoryMode;
|
||||
use codex_protocol::protocol::ThreadSettingsOverrides;
|
||||
use codex_protocol::protocol::ThreadSource;
|
||||
use codex_protocol::protocol::TokenUsage;
|
||||
use codex_protocol::user_input::UserInput;
|
||||
@@ -66,6 +78,7 @@ use codex_thread_store::PrepareForkParams;
|
||||
use core_test_support::ThreadIdle;
|
||||
use core_test_support::responses;
|
||||
use core_test_support::skip_if_no_network;
|
||||
use core_test_support::submit_thread_settings;
|
||||
use core_test_support::test_codex::TestCodex;
|
||||
use core_test_support::test_codex::test_codex;
|
||||
use core_test_support::wait_for_event;
|
||||
@@ -555,6 +568,20 @@ async fn host_factory_follows_thread_lifecycle() -> anyhow::Result<()> {
|
||||
history: Arc::new(saved.items),
|
||||
rollout_path: test.codex.rollout_path(),
|
||||
});
|
||||
let mut copied_child_options = options();
|
||||
copied_child_options
|
||||
.thread_extension_init
|
||||
.insert(InheritedSessionId(test.session_configured.session_id));
|
||||
assert!(matches!(
|
||||
manager
|
||||
.fork_thread_from_history(
|
||||
ForkSnapshot::Interrupted,
|
||||
copied_child_options,
|
||||
history.clone(),
|
||||
)
|
||||
.await,
|
||||
Err(error) if matches!(error.details(), CodexErrorDetails::InvalidRequest(_))
|
||||
));
|
||||
let fork = manager
|
||||
.fork_thread_from_history(ForkSnapshot::Interrupted, options(), history.clone())
|
||||
.await?;
|
||||
@@ -635,13 +662,58 @@ async fn hosted_child_persists_inherited_session_id(
|
||||
CodexErrorDetails::InvalidRequest(_)
|
||||
));
|
||||
let mut child_options = options();
|
||||
let prepared_fork = matches!(child_history, HostedChildHistory::PreparedFork);
|
||||
let selected_plugins = vec!["slack@openai".to_string()];
|
||||
child_options
|
||||
.thread_extension_init
|
||||
.insert(InheritedSessionId(root_session_id));
|
||||
if prepared_fork {
|
||||
child_options
|
||||
.thread_extension_init
|
||||
.insert(RestrictRootCapabilities);
|
||||
}
|
||||
let child = match child_history {
|
||||
HostedChildHistory::Fresh => manager.start_thread(child_options).await?,
|
||||
HostedChildHistory::PreparedFork => {
|
||||
responses::mount_sse_once(&server, responses::sse_completed("done")).await;
|
||||
root.submit_text_turn("record the current plugin selection")
|
||||
.await?;
|
||||
submit_thread_settings(
|
||||
&root.codex,
|
||||
ThreadSettingsOverrides {
|
||||
disabled_plugin_ids: Some(selected_plugins.clone()),
|
||||
..Default::default()
|
||||
},
|
||||
)
|
||||
.await?;
|
||||
root.codex.ensure_rollout_materialized().await;
|
||||
root.codex
|
||||
.append_rollout_items(&[
|
||||
RolloutItem::ResponseItem(ResponseItemEnvelope {
|
||||
item: responses::user_message_item("ancestor instructions"),
|
||||
metadata: Some(CodexHarnessMetadata {
|
||||
user_input_order: Some(42),
|
||||
sender_user_messages: Some(Box::new(SenderUserMessages {
|
||||
receiver_turn_id: "ancestor-turn".into(),
|
||||
receiver_message_id: "ancestor-message".into(),
|
||||
text: "ancestor sender evidence".into(),
|
||||
})),
|
||||
..Default::default()
|
||||
}),
|
||||
}),
|
||||
RolloutItem::RetainedContext(RetainedContextEvent::VerifiedAnswer {
|
||||
answer: VerifiedAnswer {
|
||||
turn_id: "ancestor-turn".into(),
|
||||
call_id: "ancestor-question".into(),
|
||||
questions: vec![VerifiedQuestionAnswer {
|
||||
question: "Publish?".into(),
|
||||
answer: "Yes".into(),
|
||||
}],
|
||||
},
|
||||
acceptance_order: Some(43),
|
||||
}),
|
||||
])
|
||||
.await?;
|
||||
root.codex.flush_rollout().await?;
|
||||
let prepared = root
|
||||
.thread_store
|
||||
@@ -663,6 +735,39 @@ async fn hosted_child_persists_inherited_session_id(
|
||||
),
|
||||
(root_session_id, None)
|
||||
);
|
||||
let mut expected_retained = None;
|
||||
if prepared_fork {
|
||||
assert_eq!(
|
||||
child
|
||||
.thread
|
||||
.thread_settings_snapshot()
|
||||
.await
|
||||
.disabled_plugin_ids,
|
||||
selected_plugins
|
||||
);
|
||||
let snapshot = child.thread.conversation_history_snapshot().await;
|
||||
assert!(snapshot.items().any(|item| matches!(
|
||||
item, ResponseItem::Message { role, content, .. }
|
||||
if role == "user" && content_items_to_text(content).as_deref() == Some("ancestor instructions")
|
||||
)));
|
||||
let retained = snapshot.retained_context().expect("child authorization");
|
||||
assert_eq!(retained.ordered_entries().count(), 0);
|
||||
assert!(retained.sender_user_messages().is_none());
|
||||
child
|
||||
.thread
|
||||
.inject_response_items(vec![responses::user_message_item(
|
||||
"child-local instructions",
|
||||
)])
|
||||
.await?;
|
||||
let snapshot = child.thread.conversation_history_snapshot().await;
|
||||
let retained = snapshot.retained_context().expect("local authorization");
|
||||
assert!(matches!(
|
||||
retained.ordered_entries().next(),
|
||||
Some((RetainedContextOrder::Local(0), RetainedContextEntry::UserMessage(message)))
|
||||
if message.text == "child-local instructions"
|
||||
));
|
||||
expected_retained = Some(retained.clone());
|
||||
}
|
||||
child.thread.ensure_rollout_materialized().await;
|
||||
child.thread.flush_rollout().await?;
|
||||
let history = root
|
||||
@@ -700,12 +805,16 @@ async fn hosted_child_persists_inherited_session_id(
|
||||
error.details(),
|
||||
CodexErrorDetails::InvalidRequest(_)
|
||||
));
|
||||
let resumed = manager
|
||||
.start_thread(StartThreadOptions {
|
||||
initial_history: resumed_history,
|
||||
..options()
|
||||
})
|
||||
.await?;
|
||||
let mut resume_options = StartThreadOptions {
|
||||
initial_history: resumed_history,
|
||||
..options()
|
||||
};
|
||||
if prepared_fork {
|
||||
resume_options
|
||||
.thread_extension_init
|
||||
.insert(RestrictRootCapabilities);
|
||||
}
|
||||
let resumed = manager.start_thread(resume_options).await?;
|
||||
assert!(!Arc::ptr_eq(&resumed.thread, &child.thread));
|
||||
assert_eq!(
|
||||
(
|
||||
@@ -715,6 +824,22 @@ async fn hosted_child_persists_inherited_session_id(
|
||||
),
|
||||
(child.thread_id, root_session_id, None)
|
||||
);
|
||||
if let Some(expected_retained) = expected_retained {
|
||||
assert_eq!(
|
||||
resumed
|
||||
.thread
|
||||
.thread_settings_snapshot()
|
||||
.await
|
||||
.disabled_plugin_ids,
|
||||
selected_plugins
|
||||
);
|
||||
let snapshot = resumed.thread.conversation_history_snapshot().await;
|
||||
assert!(snapshot.items().any(|item| matches!(
|
||||
item, ResponseItem::Message { role, content, .. }
|
||||
if role == "user" && content_items_to_text(content).as_deref() == Some("ancestor instructions")
|
||||
)));
|
||||
assert_eq!(snapshot.retained_context(), Some(&expected_retained));
|
||||
}
|
||||
resumed.thread.shutdown_and_wait().await?;
|
||||
root.codex.shutdown_and_wait().await?;
|
||||
Ok(())
|
||||
|
||||
@@ -1,13 +1,21 @@
|
||||
//! Genuine sender context stays reviewer-only and is replaced on every delivery.
|
||||
|
||||
use anyhow::Result;
|
||||
use codex_core::InheritedSessionId;
|
||||
use codex_core::RestrictRootCapabilities;
|
||||
use codex_core::TurnInputRequest;
|
||||
use codex_core::config::Constrained;
|
||||
use codex_features::Feature;
|
||||
use codex_protocol::config_types::ApprovalsReviewer;
|
||||
use codex_protocol::models::ResponseItem;
|
||||
use codex_protocol::protocol::AskForApproval;
|
||||
use codex_protocol::protocol::EventMsg;
|
||||
use codex_protocol::protocol::SessionSource;
|
||||
use codex_protocol::protocol::ThreadHistoryMode;
|
||||
use codex_protocol::turn_input::TurnInput;
|
||||
use codex_protocol::user_input::UserInput;
|
||||
use codex_thread_store::ForkBoundary;
|
||||
use codex_thread_store::PrepareForkParams;
|
||||
use core_test_support::responses;
|
||||
use core_test_support::skip_if_no_network;
|
||||
use core_test_support::test_codex::test_codex;
|
||||
@@ -203,3 +211,108 @@ async fn guardian_receives_sender_user_messages_by_default(
|
||||
assert_eq!(requests.len(), 10);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn stored_fork_sender_evidence_matches_live_sender() -> Result<()> {
|
||||
skip_if_no_network!(Ok(()));
|
||||
let server = responses::start_mock_server().await;
|
||||
let root = test_codex()
|
||||
.with_history_mode(ThreadHistoryMode::Paginated)
|
||||
.with_config(|config| {
|
||||
config.features.enable(Feature::MultiAgentV2).unwrap();
|
||||
})
|
||||
.build_with_auto_env(&server)
|
||||
.await?;
|
||||
responses::mount_sse_once(
|
||||
&server,
|
||||
responses::sse(vec![responses::ev_completed("ancestor")]),
|
||||
)
|
||||
.await;
|
||||
root.submit_text_turn("ancestor evidence").await?;
|
||||
root.codex.flush_rollout().await?;
|
||||
let prepared = root
|
||||
.thread_store
|
||||
.prepare_fork(PrepareForkParams {
|
||||
thread_id: root.session_configured.thread_id,
|
||||
boundary: ForkBoundary::Latest,
|
||||
})
|
||||
.await?;
|
||||
let mut options = root.start_thread_options().await;
|
||||
options.history_mode = Some(ThreadHistoryMode::Paginated);
|
||||
options.session_source = Some(SessionSource::Custom("host".into()));
|
||||
options
|
||||
.thread_extension_init
|
||||
.insert(InheritedSessionId(root.session_configured.session_id));
|
||||
options
|
||||
.thread_extension_init
|
||||
.insert(RestrictRootCapabilities);
|
||||
let sender = root
|
||||
.thread_manager
|
||||
.fork_prepared_thread(options, prepared)
|
||||
.await?;
|
||||
responses::mount_sse_once(
|
||||
&server,
|
||||
responses::sse(vec![responses::ev_completed("sender")]),
|
||||
)
|
||||
.await;
|
||||
sender
|
||||
.thread
|
||||
.start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
|
||||
text: "B-local evidence".into(),
|
||||
text_elements: Vec::new(),
|
||||
}]))
|
||||
.await?;
|
||||
wait_for_event(&sender.thread, |event| {
|
||||
matches!(event, EventMsg::TurnComplete(_))
|
||||
})
|
||||
.await;
|
||||
sender.thread.flush_rollout().await?;
|
||||
let remote = test_codex()
|
||||
.with_thread_store(root.thread_store.clone())
|
||||
.with_history_mode(ThreadHistoryMode::Paginated)
|
||||
.build_with_auto_env(&server)
|
||||
.await?;
|
||||
assert!(
|
||||
remote
|
||||
.thread_manager
|
||||
.get_thread(sender.thread_id)
|
||||
.await
|
||||
.is_err()
|
||||
);
|
||||
|
||||
for (index, receiver) in [&root.codex, &remote.codex].into_iter().enumerate() {
|
||||
responses::mount_sse_once(
|
||||
&server,
|
||||
responses::sse(vec![responses::ev_completed("done")]),
|
||||
)
|
||||
.await;
|
||||
let sender_id = sender.thread_id;
|
||||
let delivery: ResponseItem = serde_json::from_value(json!({
|
||||
"type": "function_call_output", "id": format!("delivery-{index}"),
|
||||
"name": "send_message", "namespace": "cloud_threads",
|
||||
"output": format!("<codex_delegation><source_thread_id>{sender_id}</source_thread_id><input>Inspect.</input></codex_delegation>"),
|
||||
}))?;
|
||||
receiver
|
||||
.start_or_steer_turn(TurnInputRequest::new(TurnInput::ResponseItem(delivery)))
|
||||
.await?;
|
||||
wait_for_event(receiver, |event| matches!(event, EventMsg::TurnComplete(_))).await;
|
||||
let history = receiver.conversation_history_snapshot().await;
|
||||
let evidence = &history
|
||||
.retained_context()
|
||||
.expect("retained context")
|
||||
.sender_user_messages()
|
||||
.expect("sender evidence")
|
||||
.text;
|
||||
assert_eq!(
|
||||
evidence
|
||||
.lines()
|
||||
.filter(|line| line.starts_with("user: ") || line.starts_with("assistant: "))
|
||||
.collect::<Vec<_>>(),
|
||||
vec!["user: B-local evidence"]
|
||||
);
|
||||
}
|
||||
sender.thread.shutdown_and_wait().await?;
|
||||
root.codex.shutdown_and_wait().await?;
|
||||
remote.codex.shutdown_and_wait().await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user