Give Guardian classifications distinct turn identities (#41385)

## What changed

- Generate a UUIDv7 turn ID for each Guardian classification and preserve it across retries.
- Record the owning turn as `parent_turn_id` and propagate its trusted `root_turn_id` when known, including through the tool lifecycle extension API.
- Omit ambiguous or unknown root lineage and keep classification identities distinct when reusing Guardian sessions and WebSocket connections.

## Testing

- Cover classification metadata across retries, connection reuse, concurrent samples, auth refresh, and consecutive owning turns.

GitOrigin-RevId: 78757f2ad031844e4b545802f634c678a9ee2298
This commit is contained in:
Eddie Chen authored and copyberry committed 2026-08-28 18:23:47 +00:00
1 parent e4d0ba4e92
commit 60fc699560
11 files changed
+221 -62

No files matched your search

+1
View File
@@ -3346,6 +3346,7 @@ dependencies = [
"thiserror 2.0.18", "thiserror 2.0.18",
"tokio", "tokio",
"tracing", "tracing",
"uuid",
] ]
[[package]] [[package]]
+24
View File
@@ -67,6 +67,8 @@ use core_test_support::PathBufExt;
use core_test_support::TempDirExt; use core_test_support::TempDirExt;
use core_test_support::context_snapshot; use core_test_support::context_snapshot;
use core_test_support::context_snapshot::ContextSnapshotOptions; use core_test_support::context_snapshot::ContextSnapshotOptions;
use core_test_support::responses::assert_parent_turn;
use core_test_support::responses::assert_root_turn;
use core_test_support::responses::ev_assistant_message; use core_test_support::responses::ev_assistant_message;
use core_test_support::responses::ev_completed; use core_test_support::responses::ev_completed;
use core_test_support::responses::ev_response_created; use core_test_support::responses::ev_response_created;
@@ -3300,6 +3302,10 @@ async fn guardian_ephemeral_retry_preserves_parallel_trunk_and_fork_history() ->
.await; .await;
let (session, turn) = guardian_test_session_and_turn_with_base_url(server.uri()).await; let (session, turn) = guardian_test_session_and_turn_with_base_url(server.uri()).await;
turn.turn_metadata_state
.set_parent_turn_id("upstream-parent-turn".to_string());
turn.turn_metadata_state
.set_root_turn_id("causal-root-turn".to_string());
seed_guardian_parent_history(&session, &turn).await; seed_guardian_parent_history(&session, &turn).await;
let initial_request = GuardianApprovalRequest::ExecCommand { let initial_request = GuardianApprovalRequest::ExecCommand {
@@ -3418,6 +3424,8 @@ async fn guardian_ephemeral_retry_preserves_parallel_trunk_and_fork_history() ->
) )
.await; .await;
// A conflicting input removes the known root while the trunk review is in flight.
turn.turn_metadata_state.mark_root_turn_ambiguous();
let third_decision = review_approval_request( let third_decision = review_approval_request(
&session, &session,
&turn, &turn,
@@ -3432,11 +3440,27 @@ async fn guardian_ephemeral_retry_preserves_parallel_trunk_and_fork_history() ->
assert_eq!(third_decision, ReviewDecision::Approved); assert_eq!(third_decision, ReviewDecision::Approved);
let requests = server.requests().await; let requests = server.requests().await;
assert_eq!(requests.len(), 4); assert_eq!(requests.len(), 4);
let first_request_body = serde_json::from_slice::<serde_json::Value>(&requests[0])?;
let second_request_body = serde_json::from_slice::<serde_json::Value>(&requests[1])?; let second_request_body = serde_json::from_slice::<serde_json::Value>(&requests[1])?;
let failed_ephemeral_request_body = let failed_ephemeral_request_body =
serde_json::from_slice::<serde_json::Value>(&requests[2])?; serde_json::from_slice::<serde_json::Value>(&requests[2])?;
let retried_ephemeral_request_body = let retried_ephemeral_request_body =
serde_json::from_slice::<serde_json::Value>(&requests[3])?; serde_json::from_slice::<serde_json::Value>(&requests[3])?;
let mut reviewer_turn_ids = std::collections::BTreeSet::new();
for (body, expected_root) in [
(&first_request_body, Some("causal-root-turn")),
(&second_request_body, Some("causal-root-turn")),
(&failed_ephemeral_request_body, None),
(&retried_ephemeral_request_body, None),
] {
assert_parent_turn(body, Some(turn.sub_id.as_str()))?;
assert_root_turn(body, expected_root)?;
assert_ne!(body["client_metadata"]["turn_id"], turn.sub_id);
reviewer_turn_ids.insert(
body["client_metadata"]["turn_id"].as_str().expect("reviewer turn id")
);
}
assert_eq!(reviewer_turn_ids.len(), 4);
assert_eq!( assert_eq!(
second_request_body["prompt_cache_key"], second_request_body["prompt_cache_key"],
failed_ephemeral_request_body["prompt_cache_key"], failed_ephemeral_request_body["prompt_cache_key"],
+2
View File
@@ -28,6 +28,7 @@ pub(crate) async fn notify_tool_start(
} }
let thread_store = &invocation.session.services.thread_extension_data; let thread_store = &invocation.session.services.thread_extension_data;
let conversation_history = invocation.session.conversation_history_snapshot().await; let conversation_history = invocation.session.conversation_history_snapshot().await;
let root_turn_id = invocation.turn.turn_metadata_state.root_turn_id();
for contributor in contributors { for contributor in contributors {
contributor contributor
@@ -36,6 +37,7 @@ pub(crate) async fn notify_tool_start(
thread_store, thread_store,
turn_store: invocation.turn.extension_data.as_ref(), turn_store: invocation.turn.extension_data.as_ref(),
turn_id: invocation.turn.sub_id.as_str(), turn_id: invocation.turn.sub_id.as_str(),
root_turn_id: root_turn_id.as_deref(),
call_id: invocation.call_id.as_str(), call_id: invocation.call_id.as_str(),
tool_name: &invocation.tool_name, tool_name: &invocation.tool_name,
mcp_tool, mcp_tool,
@@ -136,6 +136,7 @@ enum RecordedToolLifecycle {
Start { Start {
call_id: String, call_id: String,
tool_name: codex_tools::ToolName, tool_name: codex_tools::ToolName,
root_turn_id: Option<String>,
}, },
Finish { Finish {
call_id: String, call_id: String,
@@ -157,6 +158,7 @@ impl codex_extension_api::ToolLifecycleContributor for ToolLifecycleRecorder {
let record = RecordedToolLifecycle::Start { let record = RecordedToolLifecycle::Start {
call_id: input.call_id.to_string(), call_id: input.call_id.to_string(),
tool_name: input.tool_name.clone(), tool_name: input.tool_name.clone(),
root_turn_id: input.root_turn_id.map(str::to_owned),
}; };
Box::pin(async move { Box::pin(async move {
records records
@@ -640,6 +642,8 @@ fn post_tool_use_feedback_output_keeps_code_mode_result_typed() {
#[tokio::test] #[tokio::test]
async fn dispatch_uses_canonical_tool_names_for_lifecycle_contributors() -> anyhow::Result<()> { async fn dispatch_uses_canonical_tool_names_for_lifecycle_contributors() -> anyhow::Result<()> {
let (mut session, turn) = crate::session::tests::make_session_and_context().await; let (mut session, turn) = crate::session::tests::make_session_and_context().await;
turn.turn_metadata_state
.set_root_turn_id("root-turn".to_string());
let records = Arc::new(std::sync::Mutex::new(Vec::new())); let records = Arc::new(std::sync::Mutex::new(Vec::new()));
let mut builder = codex_extension_api::ExtensionRegistryBuilder::<crate::config::Config>::new(); let mut builder = codex_extension_api::ExtensionRegistryBuilder::<crate::config::Config>::new();
builder.tool_lifecycle_contributor(Arc::new(ToolLifecycleRecorder { builder.tool_lifecycle_contributor(Arc::new(ToolLifecycleRecorder {
@@ -672,6 +676,7 @@ async fn dispatch_uses_canonical_tool_names_for_lifecycle_contributors() -> anyh
/*terminal_outcome_reached*/ None, /*terminal_outcome_reached*/ None,
) )
.await?; .await?;
turn.turn_metadata_state.mark_root_turn_ambiguous();
let err = match registry let err = match registry
.dispatch_any_with_terminal_outcome( .dispatch_any_with_terminal_outcome(
test_invocation( test_invocation(
@@ -693,6 +698,7 @@ async fn dispatch_uses_canonical_tool_names_for_lifecycle_contributors() -> anyh
RecordedToolLifecycle::Start { RecordedToolLifecycle::Start {
call_id: "ok-call".to_string(), call_id: "ok-call".to_string(),
tool_name: ok_tool.clone().with_default_namespace(), tool_name: ok_tool.clone().with_default_namespace(),
root_turn_id: Some("root-turn".to_string()),
}, },
RecordedToolLifecycle::Finish { RecordedToolLifecycle::Finish {
call_id: "ok-call".to_string(), call_id: "ok-call".to_string(),
@@ -702,6 +708,7 @@ async fn dispatch_uses_canonical_tool_names_for_lifecycle_contributors() -> anyh
RecordedToolLifecycle::Start { RecordedToolLifecycle::Start {
call_id: "failing-call".to_string(), call_id: "failing-call".to_string(),
tool_name: failing_tool.clone(), tool_name: failing_tool.clone(),
root_turn_id: None,
}, },
RecordedToolLifecycle::Finish { RecordedToolLifecycle::Finish {
call_id: "failing-call".to_string(), call_id: "failing-call".to_string(),
+35 -1
View File
@@ -910,6 +910,11 @@ async fn guardian_session_is_reused_for_consecutive_tool_reviews_without_prewarm
), ),
ev_completed("resp-guardian-first-assessment"), ev_completed("resp-guardian-first-assessment"),
]), ]),
sse(vec![
ev_response_created("resp-parent-first-done"),
ev_assistant_message("msg-parent-first-done", "first done"),
ev_completed("resp-parent-first-done"),
]),
sse(vec![ sse(vec![
ev_response_created("resp-parent-second-tool"), ev_response_created("resp-parent-second-tool"),
ev_function_call( ev_function_call(
@@ -966,7 +971,7 @@ async fn guardian_session_is_reused_for_consecutive_tool_reviews_without_prewarm
test.codex test.codex
.start_or_steer_turn( .start_or_steer_turn(
TurnInputRequest::user_input(vec![UserInput::Text { TurnInputRequest::user_input(vec![UserInput::Text {
text: "run two commands that require Guardian review".into(), text: "run the first command that requires Guardian review".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}]) }])
.with_thread_settings(ThreadSettingsOverrides { .with_thread_settings(ThreadSettingsOverrides {
@@ -981,6 +986,8 @@ async fn guardian_session_is_reused_for_consecutive_tool_reviews_without_prewarm
matches!(event, EventMsg::TurnComplete(_)) matches!(event, EventMsg::TurnComplete(_))
}) })
.await; .await;
test.submit_text_turn("run the second command that requires Guardian review")
.await?;
let requests = responses.requests(); let requests = responses.requests();
assert!( assert!(
requests requests
@@ -997,6 +1004,33 @@ async fn guardian_session_is_reused_for_consecutive_tool_reviews_without_prewarm
assert_eq!(guardian_requests.len(), 3); assert_eq!(guardian_requests.len(), 3);
let first_guardian_request = guardian_requests[0].body_json(); let first_guardian_request = guardian_requests[0].body_json();
let second_guardian_request = guardian_requests[2].body_json(); let second_guardian_request = guardian_requests[2].body_json();
let first_parent_request = requests[0].body_json();
let second_parent_request = requests[4].body_json();
let first_parent_turn_id = first_parent_request["client_metadata"]["turn_id"]
.as_str()
.expect("first owning turn id");
let second_parent_turn_id = second_parent_request["client_metadata"]["turn_id"]
.as_str()
.expect("second owning turn id");
assert_ne!(first_parent_turn_id, second_parent_turn_id);
for (request, parent_turn_id) in guardian_requests.iter().zip([
first_parent_turn_id,
first_parent_turn_id,
second_parent_turn_id,
]) {
let body = request.body_json();
assert_parent_turn(&body, Some(parent_turn_id))?;
assert_root_turn(&body, Some(parent_turn_id))?;
assert_ne!(body["client_metadata"]["turn_id"], parent_turn_id);
assert_eq!(
body["client_metadata"]["session_id"],
first_parent_request["client_metadata"]["session_id"]
);
}
assert_ne!(
first_guardian_request["client_metadata"]["turn_id"],
second_guardian_request["client_metadata"]["turn_id"]
);
let first_guardian_thread_id = first_guardian_request["client_metadata"]["thread_id"] let first_guardian_thread_id = first_guardian_request["client_metadata"]["thread_id"]
.as_str() .as_str()
.expect("first Guardian review should have a thread id"); .expect("first Guardian review should have a thread id");
@@ -123,6 +123,8 @@ pub struct ToolStartInput<'a> {
pub turn_store: &'a ExtensionData, pub turn_store: &'a ExtensionData,
/// Current turn submission id. /// Current turn submission id.
pub turn_id: &'a str, pub turn_id: &'a str,
/// Trusted causal root of the owning turn, absent when unknown or ambiguous.
pub root_turn_id: Option<&'a str>,
/// Model-visible tool call id. /// Model-visible tool call id.
pub call_id: &'a str, pub call_id: &'a str,
/// Tool name as routed by the host. /// Tool name as routed by the host.
+1
View File
@@ -30,6 +30,7 @@ serde_json = { workspace = true }
thiserror = { workspace = true } thiserror = { workspace = true }
tokio = { workspace = true, features = ["time"] } tokio = { workspace = true, features = ["time"] }
tracing = { workspace = true } tracing = { workspace = true }
uuid = { workspace = true }
[dev-dependencies] [dev-dependencies]
anyhow = { workspace = true } anyhow = { workspace = true }
@@ -409,6 +409,7 @@ impl GuardianV2Extension {
let event_sink = Arc::clone(&self.event_sink); let event_sink = Arc::clone(&self.event_sink);
let thread_id = input.thread_store.level_id().to_owned(); let thread_id = input.thread_store.level_id().to_owned();
let turn_id = input.turn_id.to_owned(); let turn_id = input.turn_id.to_owned();
let root_turn_id = input.root_turn_id.map(str::to_owned);
let thread_context: Result<_, String> = async { let thread_context: Result<_, String> = async {
let parsed_thread_id = let parsed_thread_id =
ThreadId::from_string(&thread_id).map_err(|error| error.to_string())?; ThreadId::from_string(&thread_id).map_err(|error| error.to_string())?;
@@ -681,7 +682,8 @@ impl GuardianV2Extension {
parent_compaction, parent_compaction,
parent_compaction_hash, parent_compaction_hash,
reasoning_effort: guardian_config.reasoning_effort.clone(), reasoning_effort: guardian_config.reasoning_effort.clone(),
turn_id: turn_id.clone(), parent_turn_id: turn_id.clone(),
root_turn_id,
}) })
.await .await
{ {
@@ -227,6 +227,7 @@ async fn installed_extension_reconnects_after_auth_refresh() -> Result<()> {
thread_store, thread_store,
turn_store: &turn_store, turn_store: &turn_store,
turn_id: "turn-1", turn_id: "turn-1",
root_turn_id: None,
call_id, call_id,
tool_name: &tool_name, tool_name: &tool_name,
mcp_tool: None, mcp_tool: None,
@@ -276,6 +277,20 @@ async fn installed_extension_reconnects_after_auth_refresh() -> Result<()> {
.collect::<Vec<_>>(), .collect::<Vec<_>>(),
expected_requests expected_requests
); );
let requests = server
.connections()
.into_iter()
.flatten()
.map(|request| request.body_json())
.collect::<Vec<_>>();
for request in &requests {
responses::assert_parent_turn(request, Some("turn-1"))?;
responses::assert_root_turn(request, /*expected*/ None)?;
}
assert_ne!(
requests[0]["client_metadata"]["turn_id"],
requests[1]["client_metadata"]["turn_id"]
);
Ok(()) Ok(())
} }
@@ -439,6 +454,7 @@ async fn sandboxed_shell_classification_respects_review_scope() -> Result<()> {
thread_store, thread_store,
turn_store: &turn_store, turn_store: &turn_store,
turn_id: "turn-1", turn_id: "turn-1",
root_turn_id: None,
call_id: "call-2", call_id: "call-2",
tool_name: &tool_name, tool_name: &tool_name,
mcp_tool: None, mcp_tool: None,
@@ -518,6 +534,7 @@ async fn computer_use_only_scores_cannot_approve_other_actions() -> Result<()> {
thread_store, thread_store,
turn_store: &turn_store, turn_store: &turn_store,
turn_id: "turn-1", turn_id: "turn-1",
root_turn_id: None,
call_id: "ordinary-call", call_id: "ordinary-call",
tool_name: &ordinary_tool, tool_name: &ordinary_tool,
mcp_tool: None, mcp_tool: None,
@@ -952,6 +969,7 @@ async fn sample_configured_conversation_history_with_source(
thread_store, thread_store,
turn_store: &turn_store, turn_store: &turn_store,
turn_id: "turn-1", turn_id: "turn-1",
root_turn_id: Some("root-turn"),
call_id: "call-1", call_id: "call-1",
tool_name: &tool_name, tool_name: &tool_name,
mcp_tool: None, mcp_tool: None,
@@ -1027,6 +1045,7 @@ impl GuardianFailureFixture {
thread_store, thread_store,
turn_store: &turn_store, turn_store: &turn_store,
turn_id: "turn-1", turn_id: "turn-1",
root_turn_id: None,
call_id: "call-1", call_id: "call-1",
tool_name: &tool_name, tool_name: &tool_name,
mcp_tool: None, mcp_tool: None,
@@ -1876,6 +1895,9 @@ async fn contributor_samples_tool_calls_with_the_existing_luna_pool() -> Result<
.as_str() .as_str()
.expect("classifier thread ID"); .expect("classifier thread ID");
assert_ne!(ThreadId::from_string(classifier_thread_id)?, thread_id); assert_ne!(ThreadId::from_string(classifier_thread_id)?, thread_id);
let classifier_turn_id = request["client_metadata"]["turn_id"]
.as_str()
.expect("classifier turn ID");
let turn_metadata: serde_json::Value = serde_json::from_str( let turn_metadata: serde_json::Value = serde_json::from_str(
request["client_metadata"]["x-codex-turn-metadata"] request["client_metadata"]["x-codex-turn-metadata"]
.as_str() .as_str()
@@ -1887,7 +1909,9 @@ async fn contributor_samples_tool_calls_with_the_existing_luna_pool() -> Result<
"session_id": request["client_metadata"]["session_id"], "session_id": request["client_metadata"]["session_id"],
"thread_id": classifier_thread_id, "thread_id": classifier_thread_id,
"guardian_classifier_source_thread_id": thread_id.to_string(), "guardian_classifier_source_thread_id": thread_id.to_string(),
"turn_id": "turn-1", "turn_id": classifier_turn_id,
"parent_turn_id": "turn-1",
"root_turn_id": "root-turn",
"thread_source": "guardian_classifier", "thread_source": "guardian_classifier",
}) })
); );
@@ -1896,7 +1920,8 @@ async fn contributor_samples_tool_calls_with_the_existing_luna_pool() -> Result<
request["client_metadata"]["x-codex-window-id"], request["client_metadata"]["x-codex-window-id"],
format!("{classifier_thread_id}:0") format!("{classifier_thread_id}:0")
); );
assert_eq!(request["client_metadata"]["turn_id"], "turn-1"); assert_eq!(request["client_metadata"]["parent_turn_id"], "turn-1");
assert_eq!(request["client_metadata"]["root_turn_id"], "root-turn");
assert_eq!(request["reasoning"]["effort"], "low"); assert_eq!(request["reasoning"]["effort"], "low");
assert_eq!(request["reasoning"]["context"], "all_turns"); assert_eq!(request["reasoning"]["context"], "all_turns");
assert!(request.get("text").is_none()); assert!(request.get("text").is_none());
@@ -2205,6 +2230,7 @@ async fn contributor_skips_required_models_in_standard_scope() -> Result<()> {
thread_store, thread_store,
turn_store: &turn_store, turn_store: &turn_store,
turn_id: "turn-1", turn_id: "turn-1",
root_turn_id: None,
call_id: "protected.md", call_id: "protected.md",
tool_name: &tool_name, tool_name: &tool_name,
mcp_tool: None, mcp_tool: None,
@@ -2286,6 +2312,7 @@ async fn contributor_counts_failed_thread_lookups_toward_score_lag() -> Result<(
thread_store, thread_store,
turn_store: &turn_store, turn_store: &turn_store,
turn_id: "turn-1", turn_id: "turn-1",
root_turn_id: None,
call_id: "missing.md", call_id: "missing.md",
tool_name: &tool_name, tool_name: &tool_name,
mcp_tool: None, mcp_tool: None,
@@ -2674,6 +2701,7 @@ async fn contributor_reuses_the_latest_compatible_parent_compaction() -> Result<
thread_store, thread_store,
turn_store: &turn_store, turn_store: &turn_store,
turn_id: "turn-1", turn_id: "turn-1",
root_turn_id: None,
call_id: "call-1", call_id: "call-1",
tool_name: &tool_name, tool_name: &tool_name,
mcp_tool: None, mcp_tool: None,
@@ -2744,6 +2772,7 @@ async fn contributor_reuses_the_latest_compatible_parent_compaction() -> Result<
thread_store, thread_store,
turn_store: &turn_store, turn_store: &turn_store,
turn_id: "turn-1", turn_id: "turn-1",
root_turn_id: None,
call_id: "call-2", call_id: "call-2",
tool_name: &tool_name, tool_name: &tool_name,
mcp_tool: None, mcp_tool: None,
@@ -44,6 +44,7 @@ use thiserror::Error;
use tokio::sync::OwnedSemaphorePermit; use tokio::sync::OwnedSemaphorePermit;
use tokio::sync::Semaphore; use tokio::sync::Semaphore;
use tokio::sync::oneshot; use tokio::sync::oneshot;
use uuid::Uuid;
use super::trusted_skills::GuardianTrustedSkillsFragment; use super::trusted_skills::GuardianTrustedSkillsFragment;
use super::trusted_tools::GuardianTrustedToolFragment; use super::trusted_tools::GuardianTrustedToolFragment;
@@ -107,8 +108,10 @@ pub struct LunaSamplingRequest {
pub parent_compaction_hash: Option<String>, pub parent_compaction_hash: Option<String>,
/// Reasoning budget explicitly selected for this request. /// Reasoning budget explicitly selected for this request.
pub reasoning_effort: ReasoningEffort, pub reasoning_effort: ReasoningEffort,
/// Owning turn identifier used for request attribution. /// Owning turn that initiated this classification, not the classifier turn.
pub turn_id: String, pub parent_turn_id: String,
/// Trusted causal root of the owning turn, absent when unknown or ambiguous.
pub root_turn_id: Option<String>,
} }
/// Failures returned while connecting or sampling the Luna model. /// Failures returned while connecting or sampling the Luna model.
@@ -429,7 +432,10 @@ impl LunaSampler {
/// Sends one tool-less classification request on an exclusively leased WebSocket. /// Sends one tool-less classification request on an exclusively leased WebSocket.
pub async fn sample(&self, request: LunaSamplingRequest) -> Result<String, LunaSamplerError> { pub async fn sample(&self, request: LunaSamplingRequest) -> Result<String, LunaSamplerError> {
let turn_id = request.turn_id; // A classification is its own inference turn; retries keep that identity.
let turn_id = Uuid::now_v7().to_string();
let parent_turn_id = request.parent_turn_id;
let root_turn_id = request.root_turn_id;
let mut input = vec![ let mut input = vec![
ResponseItem::AdditionalTools { ResponseItem::AdditionalTools {
id: None, id: None,
@@ -587,24 +593,30 @@ impl LunaSampler {
self.config.service_tier.clone() self.config.service_tier.clone()
}; };
let thread_id = &lease.connection.thread_id; let thread_id = &lease.connection.thread_id;
let turn_metadata = json!({ let mut turn_metadata = json!({
"session_id": self.config.session_id, "session_id": self.config.session_id,
"thread_id": thread_id, "thread_id": thread_id,
"guardian_classifier_source_thread_id": self.config.thread_id, "guardian_classifier_source_thread_id": self.config.thread_id,
"turn_id": turn_id, "turn_id": turn_id,
"parent_turn_id": parent_turn_id,
"thread_source": "guardian_classifier", "thread_source": "guardian_classifier",
}) });
.to_string(); let mut client_metadata = HashMap::from([
request.client_metadata = Some(HashMap::from([
("session_id".to_owned(), self.config.session_id.clone()), ("session_id".to_owned(), self.config.session_id.clone()),
("thread_id".to_owned(), thread_id.clone()), ("thread_id".to_owned(), thread_id.clone()),
("turn_id".to_owned(), turn_id.clone()), ("turn_id".to_owned(), turn_id.clone()),
("parent_turn_id".to_owned(), parent_turn_id.clone()),
("x-openai-subagent".to_owned(), "guardian".to_owned()), ("x-openai-subagent".to_owned(), "guardian".to_owned()),
// Classifier requests do not advance their own context window. // Classifier requests do not advance their own context window.
("x-codex-window-id".to_owned(), format!("{thread_id}:0")), ("x-codex-window-id".to_owned(), format!("{thread_id}:0")),
(RESPONSES_LITE_METADATA_KEY.to_owned(), "true".to_owned()), (RESPONSES_LITE_METADATA_KEY.to_owned(), "true".to_owned()),
(TURN_METADATA_KEY.to_owned(), turn_metadata), ]);
])); if let Some(root_turn_id) = &root_turn_id {
client_metadata.insert("root_turn_id".to_owned(), root_turn_id.clone());
turn_metadata["root_turn_id"] = json!(root_turn_id);
}
client_metadata.insert(TURN_METADATA_KEY.to_owned(), turn_metadata.to_string());
request.client_metadata = Some(client_metadata);
let mut stream = match lease let mut stream = match lease
.connection .connection
.connection .connection
@@ -33,6 +33,7 @@ use std::sync::atomic::Ordering;
use std::time::Duration; use std::time::Duration;
use tokio::net::TcpListener; use tokio::net::TcpListener;
use tokio::net::TcpStream; use tokio::net::TcpStream;
use uuid::Uuid;
use super::CLASSIFICATION_TOKEN_USAGE_METRIC; use super::CLASSIFICATION_TOKEN_USAGE_METRIC;
use super::INITIAL_WEBSOCKET_CONNECTIONS; use super::INITIAL_WEBSOCKET_CONNECTIONS;
@@ -55,7 +56,10 @@ impl LunaSampler {
} }
} }
fn assert_connection_metadata(server: &responses::WebSocketTestServer) -> Result<String> { fn assert_connection_metadata(
server: &responses::WebSocketTestServer,
expected_lineage: &[(&str, Option<&str>)],
) -> Result<String> {
let handshake = server.single_handshake(); let handshake = server.single_handshake();
let thread_id = handshake.header("thread-id").expect("classifier thread ID"); let thread_id = handshake.header("thread-id").expect("classifier thread ID");
ThreadId::from_string(&thread_id)?; ThreadId::from_string(&thread_id)?;
@@ -72,32 +76,43 @@ fn assert_connection_metadata(server: &responses::WebSocketTestServer) -> Result
Some(format!("{thread_id}:0")), Some(format!("{thread_id}:0")),
] ]
); );
for request in server.single_connection() { let requests = server.single_connection();
assert_eq!(requests.len(), expected_lineage.len());
for (request, (parent_turn_id, root_turn_id)) in requests.iter().zip(expected_lineage) {
let mut metadata = request.body_json()["client_metadata"].clone(); let mut metadata = request.body_json()["client_metadata"].clone();
let turn_id = metadata["turn_id"].clone(); let turn_id = metadata["turn_id"]
.as_str()
.expect("classifier turn ID")
.to_owned();
assert_eq!(Uuid::parse_str(&turn_id)?.get_version_num(), 7);
assert_ne!(turn_id.as_str(), *parent_turn_id);
metadata["x-codex-turn-metadata"] = serde_json::from_str( metadata["x-codex-turn-metadata"] = serde_json::from_str(
metadata["x-codex-turn-metadata"] metadata["x-codex-turn-metadata"]
.as_str() .as_str()
.expect("serialized turn metadata"), .expect("serialized turn metadata"),
)?; )?;
assert_eq!( let mut expected = json!({
metadata, "session_id": "session-1",
json!({ "thread_id": thread_id,
"turn_id": turn_id,
"parent_turn_id": parent_turn_id,
"x-openai-subagent": "guardian",
"x-codex-window-id": format!("{thread_id}:0"),
"ws_request_header_x_openai_internal_codex_responses_lite": "true",
"x-codex-turn-metadata": {
"session_id": "session-1", "session_id": "session-1",
"thread_id": thread_id, "thread_id": thread_id,
"guardian_classifier_source_thread_id": "thread-1",
"turn_id": turn_id, "turn_id": turn_id,
"x-openai-subagent": "guardian", "parent_turn_id": parent_turn_id,
"x-codex-window-id": format!("{thread_id}:0"), "thread_source": "guardian_classifier",
"ws_request_header_x_openai_internal_codex_responses_lite": "true", },
"x-codex-turn-metadata": { });
"session_id": "session-1", if let Some(root_turn_id) = root_turn_id {
"thread_id": thread_id, expected["root_turn_id"] = json!(root_turn_id);
"guardian_classifier_source_thread_id": "thread-1", expected["x-codex-turn-metadata"]["root_turn_id"] = json!(root_turn_id);
"turn_id": turn_id, }
"thread_source": "guardian_classifier", assert_eq!(metadata, expected);
},
})
);
} }
Ok(thread_id) Ok(thread_id)
} }
@@ -174,7 +189,7 @@ async fn connect_sampler(config: LunaSamplerConfig) -> Result<LunaSampler> {
Ok(sampler) Ok(sampler)
} }
fn sample_request(turn_id: &str) -> LunaSamplingRequest { fn sample_request(parent_turn_id: &str) -> LunaSamplingRequest {
LunaSamplingRequest { LunaSamplingRequest {
instructions: "Return high for high risk or low for low risk.".to_owned(), instructions: "Return high for high risk or low for low risk.".to_owned(),
trusted_review_evidence: Vec::new(), trusted_review_evidence: Vec::new(),
@@ -185,7 +200,8 @@ fn sample_request(turn_id: &str) -> LunaSamplingRequest {
parent_compaction: None, parent_compaction: None,
parent_compaction_hash: None, parent_compaction_hash: None,
reasoning_effort: ReasoningEffort::None, reasoning_effort: ReasoningEffort::None,
turn_id: turn_id.to_owned(), parent_turn_id: parent_turn_id.to_owned(),
root_turn_id: None,
} }
} }
@@ -359,8 +375,14 @@ async fn preconnected_sampler_reuses_authenticated_websocket_for_classifications
], ],
]; ];
let idle_server = responses::start_websocket_server(vec![scripted_requests.clone()]).await; let idle_server = responses::start_websocket_server(vec![scripted_requests.clone()]).await;
let refreshed = let refreshed = responses::start_websocket_server(vec![vec![
responses::start_websocket_server(vec![vec![scripted_requests[1].clone()]]).await; scripted_requests[1].clone(),
vec![
ev_assistant_message("sample-3", "low"),
ev_completed("response-3"),
],
]])
.await;
let server = responses::start_websocket_server(vec![scripted_requests]).await; let server = responses::start_websocket_server(vec![scripted_requests]).await;
let base_url = proxy_websocket_servers_with_prewarm_limit( let base_url = proxy_websocket_servers_with_prewarm_limit(
&[&idle_server, &server, &refreshed], &[&idle_server, &server, &refreshed],
@@ -435,7 +457,8 @@ async fn preconnected_sampler_reuses_authenticated_websocket_for_classifications
parent_compaction: None, parent_compaction: None,
parent_compaction_hash: None, parent_compaction_hash: None,
reasoning_effort: ReasoningEffort::None, reasoning_effort: ReasoningEffort::None,
turn_id: "turn-1".to_owned(), parent_turn_id: "turn-1".to_owned(),
root_turn_id: Some("turn-1".to_owned()),
}) })
.await?; .await?;
tokio::time::timeout(Duration::from_secs(2), async { tokio::time::timeout(Duration::from_secs(2), async {
@@ -462,12 +485,15 @@ async fn preconnected_sampler_reuses_authenticated_websocket_for_classifications
parent_compaction: None, parent_compaction: None,
parent_compaction_hash: None, parent_compaction_hash: None,
reasoning_effort: ReasoningEffort::Medium, reasoning_effort: ReasoningEffort::Medium,
turn_id: "turn-2".to_owned(), parent_turn_id: "turn-2".to_owned(),
root_turn_id: Some("root-2".to_owned()),
}) })
.await?; .await?;
assert_eq!(first, "low"); assert_eq!(first, "low");
assert_eq!(second, "high"); assert_eq!(second, "high");
// Reuse the same socket after a nested owner, now with unknown root lineage.
assert_eq!(sampler.sample(sample_request("turn-3")).await?, "low");
let mut requests = server.single_connection(); let mut requests = server.single_connection();
assert_eq!(requests.len(), 1); assert_eq!(requests.len(), 1);
assert_eq!( assert_eq!(
@@ -475,8 +501,13 @@ async fn preconnected_sampler_reuses_authenticated_websocket_for_classifications
Some("Bearer refreshed".to_owned()) Some("Bearer refreshed".to_owned())
); );
requests.extend(refreshed.single_connection()); requests.extend(refreshed.single_connection());
assert_eq!(requests.len(), 2); assert_eq!(requests.len(), 3);
let thread_id = assert_connection_metadata(&server)?; let thread_id = assert_connection_metadata(&server, &[("turn-1", Some("turn-1"))])?;
assert_connection_metadata(&refreshed, &[("turn-2", Some("root-2")), ("turn-3", None)])?;
assert_ne!(
requests[1].body_json()["client_metadata"]["turn_id"],
requests[2].body_json()["client_metadata"]["turn_id"]
);
assert_ne!( assert_ne!(
Some(thread_id), Some(thread_id),
idle_server.single_handshake().header("thread-id") idle_server.single_handshake().header("thread-id")
@@ -496,12 +527,8 @@ async fn preconnected_sampler_reuses_authenticated_websocket_for_classifications
assert_eq!(request["tool_choice"], "none"); assert_eq!(request["tool_choice"], "none");
assert!(request.get("text").is_none()); assert!(request.get("text").is_none());
assert_eq!(request["prompt_cache_key"], "guardian-v2:thread-1"); assert_eq!(request["prompt_cache_key"], "guardian-v2:thread-1");
assert_eq!(
request["client_metadata"]["turn_id"],
format!("turn-{}", index + 1)
);
assert!(request.get("tools").is_none()); assert!(request.get("tools").is_none());
let effort = if index == 0 { "none" } else { "medium" }; let effort = if index == 1 { "medium" } else { "none" };
assert_eq!(request["reasoning"]["effort"], effort); assert_eq!(request["reasoning"]["effort"], effort);
assert_eq!(request["reasoning"]["context"], "all_turns"); assert_eq!(request["reasoning"]["context"], "all_turns");
} }
@@ -631,7 +658,8 @@ async fn sampler_returns_classification_token_before_terminal_response_events()
parent_compaction: None, parent_compaction: None,
parent_compaction_hash: None, parent_compaction_hash: None,
reasoning_effort: ReasoningEffort::None, reasoning_effort: ReasoningEffort::None,
turn_id: "turn-1".to_owned(), parent_turn_id: "turn-1".to_owned(),
root_turn_id: Some("turn-1".to_owned()),
}), }),
) )
.await??; .await??;
@@ -744,9 +772,13 @@ async fn sampler_grows_its_pool_for_overlapping_requests() -> Result<()> {
)) ))
.await?; .await?;
let mut first_request = sample_request("turn-1");
first_request.root_turn_id = Some("root-1".to_owned());
let mut second_request = sample_request("turn-2");
second_request.root_turn_id = Some("root-2".to_owned());
let outputs = tokio::try_join!( let outputs = tokio::try_join!(
sampler.sample(sample_request("turn-1")), sampler.sample(first_request),
sampler.sample(sample_request("turn-2")), sampler.sample(second_request),
sampler.sample(sample_request("turn-3")), sampler.sample(sample_request("turn-3")),
)?; )?;
@@ -756,18 +788,26 @@ async fn sampler_grows_its_pool_for_overlapping_requests() -> Result<()> {
); );
let mut thread_ids = HashSet::new(); let mut thread_ids = HashSet::new();
let mut turn_ids = HashSet::new(); let mut turn_ids = HashSet::new();
let mut parent_turn_ids = HashSet::new();
for server in [&first, &second, &third] { for server in [&first, &second, &third] {
assert_eq!(server.single_connection().len(), 1); assert_eq!(server.single_connection().len(), 1);
assert!(thread_ids.insert(assert_connection_metadata(server)?)); let metadata = server.single_connection()[0].body_json()["client_metadata"].clone();
turn_ids.insert( let parent_turn_id = metadata["parent_turn_id"].as_str().expect("owning turn ID");
server.single_connection()[0].body_json()["client_metadata"]["turn_id"] let expected_root = match parent_turn_id {
.as_str() "turn-1" => Some("root-1"),
.expect("turn ID") "turn-2" => Some("root-2"),
.to_owned(), "turn-3" => None,
); other => panic!("unexpected owning turn: {other}"),
};
assert!(thread_ids.insert(assert_connection_metadata(
server,
&[(parent_turn_id, expected_root)]
)?));
assert!(turn_ids.insert(metadata["turn_id"].as_str().expect("turn ID").to_owned()));
parent_turn_ids.insert(parent_turn_id.to_owned());
} }
assert_eq!( assert_eq!(
turn_ids, parent_turn_ids,
HashSet::from_iter([ HashSet::from_iter([
"turn-1".to_owned(), "turn-1".to_owned(),
"turn-2".to_owned(), "turn-2".to_owned(),
@@ -907,6 +947,7 @@ async fn sampler_retries_expired_websockets_on_another_warm_connection() -> Resu
let mut request = sample_request("turn-1"); let mut request = sample_request("turn-1");
request.trusted_review_evidence = vec!["trusted review".to_owned()]; request.trusted_review_evidence = vec!["trusted review".to_owned()];
request.trusted_skill_paths = vec!["/skills/review/SKILL.md".to_owned()]; request.trusted_skill_paths = vec!["/skills/review/SKILL.md".to_owned()];
request.root_turn_id = Some("root-turn".to_owned());
let output = sampler.sample(request).await?; let output = sampler.sample(request).await?;
assert_eq!(output, "low"); assert_eq!(output, "low");
@@ -915,13 +956,16 @@ async fn sampler_retries_expired_websockets_on_another_warm_connection() -> Resu
assert_eq!(expired_requests.len(), 1); assert_eq!(expired_requests.len(), 1);
assert_eq!(healthy_requests.len(), 1); assert_eq!(healthy_requests.len(), 1);
assert_ne!( assert_ne!(
assert_connection_metadata(&expired)?, assert_connection_metadata(&expired, &[("turn-1", Some("root-turn"))])?,
assert_connection_metadata(&healthy)? assert_connection_metadata(&healthy, &[("turn-1", Some("root-turn"))])?
); );
let mut expired_request = expired_requests[0].body_json(); let mut expired_request = expired_requests[0].body_json();
let mut healthy_request = healthy_requests[0].body_json(); let mut healthy_request = healthy_requests[0].body_json();
assert_eq!(
expired_request["client_metadata"]["turn_id"],
healthy_request["client_metadata"]["turn_id"],
);
for request in [&mut expired_request, &mut healthy_request] { for request in [&mut expired_request, &mut healthy_request] {
assert_eq!(request["client_metadata"]["turn_id"], "turn-1");
request request
.as_object_mut() .as_object_mut()
.expect("request object") .expect("request object")
@@ -969,10 +1013,11 @@ async fn sampler_assigns_a_fresh_identity_when_replacing_aged_connections() -> R
} }
assert_eq!(sampler.sample(sample_request("turn-2")).await?, "low"); assert_eq!(sampler.sample(sample_request("turn-2")).await?, "low");
let thread_ids = [&first, &second, &replacement] let thread_ids = HashSet::from([
.into_iter() assert_connection_metadata(&first, &[])?,
.map(assert_connection_metadata) assert_connection_metadata(&second, &[("turn-1", None)])?,
.collect::<Result<HashSet<_>>>()?; assert_connection_metadata(&replacement, &[("turn-2", None)])?,
]);
assert_eq!(thread_ids.len(), 3); assert_eq!(thread_ids.len(), 3);
assert_eq!(second.single_connection().len(), 1); assert_eq!(second.single_connection().len(), 1);
assert_eq!(replacement.single_connection().len(), 1); assert_eq!(replacement.single_connection().len(), 1);