Lightweight coding agent that runs in your terminal
Rust
Replace Guardian tickets with parent response IDs (#43002)
jifdee21ec1bc26
diff --git a/codex-rs/app-server/tests/suite/v2/client_metadata.rs b/codex-rs/app-server/tests/suite/v2/client_metadata.rsindex 36a5f85834..6c0ac094bd 100644--- a/codex-rs/app-server/tests/suite/v2/client_metadata.rs+++ b/codex-rs/app-server/tests/suite/v2/client_metadata.rs@@ -73,6 +73,10 @@ async fn turn_start_forwards_client_metadata_to_responses_request_v2() -> Resulttimeout(DEFAULT_READ_TIMEOUT, mcp.read_response(thread_req)).await??;let client_metadata = HashMap::from([+ (+ "parent_response_id".to_string(),+ "client-correlation".to_string(),+ ),("fiber_run_id".to_string(), "fiber-start-123".to_string()),("origin".to_string(), "gaas".to_string()),(@@ -109,6 +113,20 @@ async fn turn_start_forwards_client_metadata_to_responses_request_v2() -> Result.as_deref().map(parse_json_header).expect("x-codex-turn-metadata header should be present");+ let body = request.body_json();+ let body_turn_metadata = parse_json_header(+ body["client_metadata"]["x-codex-turn-metadata"]+ .as_str()+ .expect("turn metadata"),+ );+ assert_eq!(+ (+ metadata["parent_response_id"].as_str(),+ body_turn_metadata["parent_response_id"].as_str(),+ body["client_metadata"].get("parent_response_id"),+ ),+ (Some("client-correlation"), Some("client-correlation"), None),+ );assert_eq!(metadata["fiber_run_id"].as_str(), Some("fiber-start-123"));assert_eq!(metadata["origin"].as_str(), Some("gaas"));assert_eq!(metadata["thread_source"].as_str(), Some("automation"));@@ -603,6 +621,10 @@ async fn turn_start_forwards_client_metadata_to_responses_websocket_request_bodytimeout(DEFAULT_READ_TIMEOUT, mcp.read_response(thread_req)).await??;let client_metadata = HashMap::from([+ (+ "parent_response_id".to_string(),+ "client-correlation".to_string(),+ ),("fiber_run_id".to_string(), "fiber-start-123".to_string()),("origin".to_string(), "gaas".to_string()),]);@@ -646,6 +668,13 @@ async fn turn_start_forwards_client_metadata_to_responses_websocket_request_body.as_str().map(parse_json_header).expect("websocket x-codex-turn-metadata client metadata should be present");+ assert_eq!(+ (+ metadata["parent_response_id"].as_str(),+ request["client_metadata"].get("parent_response_id"),+ ),+ (Some("client-correlation"), None),+ );assert_eq!(metadata["fiber_run_id"].as_str(), Some("fiber-start-123"));assert_eq!(metadata["origin"].as_str(), Some("gaas"));assert_eq!(metadata["thread_source"].as_str(), Some("automation"));diff --git a/codex-rs/codex-api/src/common.rs b/codex-rs/codex-api/src/common.rsindex c457285afd..a2c9c5a643 100644--- a/codex-rs/codex-api/src/common.rs+++ b/codex-rs/codex-api/src/common.rs@@ -94,11 +94,15 @@ pub struct MemorySummarizeOutput {pub memory_summary: String,}+/// The server response currently being handled, shared with tool-review extensions.+#[derive(Clone, Debug)]+pub struct ResponseId(pub String);+#[derive(Debug)]pub enum ResponseEvent {Created {- /// Runtime-only receipt for this exact server response.- guardian_ticket: Option<codex_protocol::guardian_ticket::GuardianTicket>,+ /// Existing server response ID, when supplied by the stream.+ response_id: Option<String>,},SafetyBuffering(SafetyBuffering),OutputItemDone(ResponseItem),diff --git a/codex-rs/codex-api/src/endpoint/responses.rs b/codex-rs/codex-api/src/endpoint/responses.rsindex fa746f0e58..78a08232f9 100644--- a/codex-rs/codex-api/src/endpoint/responses.rs+++ b/codex-rs/codex-api/src/endpoint/responses.rs@@ -60,8 +60,6 @@ pub struct ResponsesOptions {pub extra_headers: HeaderMap,pub compression: Compression,pub turn_state: Option<Arc<OnceLock<String>>>,- /// Runtime-only parent receipt, attached after inference tracing.- pub guardian_ticket: Option<codex_protocol::guardian_ticket::GuardianTicket>,}impl<T: HttpTransport> ResponsesClient<T> {@@ -103,7 +101,7 @@ impl<T: HttpTransport> ResponsesClient<T> {)]pub async fn stream_request(&self,- mut request: ResponsesApiRequest,+ request: ResponsesApiRequest,options: ResponsesOptions,) -> Result<ResponseStream, ApiError> {let ResponsesOptions {@@ -113,19 +111,9 @@ impl<T: HttpTransport> ResponsesClient<T> {extra_headers,compression,turn_state,- guardian_ticket,} = options;- crate::guardian_ticket::attach(- &mut request.client_metadata,- guardian_ticket.as_ref(),- self.endpoint,- );-- let mut body = EncodedJsonBody::encode(&request)+ let body = EncodedJsonBody::encode(&request).map_err(|e| ApiError::Stream(format!("failed to encode responses request: {e}")))?;- if guardian_ticket.is_some() {- body = body.without_body_logging();- }let mut headers = extra_headers;if let Some(ref thread_id) = thread_id {diff --git a/codex-rs/codex-api/src/endpoint/responses_websocket.rs b/codex-rs/codex-api/src/endpoint/responses_websocket.rsindex 0f928d1cff..95d41e0d91 100644--- a/codex-rs/codex-api/src/endpoint/responses_websocket.rs+++ b/codex-rs/codex-api/src/endpoint/responses_websocket.rs@@ -234,10 +234,9 @@ impl ResponsesWebsocketConnection {)]pub async fn stream_request(&self,- mut request: ResponsesWsRequest<'_>,+ request: ResponsesWsRequest<'_>,connection_reused: bool,turn_state: Option<Arc<OnceLock<String>>>,- guardian_ticket: Option<&codex_protocol::guardian_ticket::GuardianTicket>,) -> Result<ResponseStream, ApiError> {let (tx_event, rx_event) =mpsc::channel::<std::result::Result<ResponseEvent, ApiError>>(1600);@@ -271,12 +270,6 @@ impl ResponsesWebsocketConnection {warmup: ws_request.generate == Some(false),connection_reused,};- let ResponsesWsRequest::ResponseCreate(ws_request) = &mut request;- crate::guardian_ticket::attach(- &mut ws_request.client_metadata,- guardian_ticket,- self.endpoint,- );let request_text = serialize_websocket_request(&request)?;let current_span = Span::current();diff --git a/codex-rs/codex-api/src/guardian_ticket.rs b/codex-rs/codex-api/src/guardian_ticket.rsdeleted file mode 100644index 94a7660055..0000000000--- a/codex-rs/codex-api/src/guardian_ticket.rs+++ /dev/null@@ -1,33 +0,0 @@-//! Adds opaque receipts only to Guardian requests at the transport boundary.--use std::collections::HashMap;--use crate::endpoint::responses::ResponsesEndpoint;--use codex_protocol::guardian_ticket::GUARDIAN_TICKET_METADATA_KEY;-use codex_protocol::guardian_ticket::GuardianTicket;--pub(crate) fn attach(- metadata: &mut Option<HashMap<String, String>>,- ticket: Option<&GuardianTicket>,- endpoint: ResponsesEndpoint,-) {- if let Some(metadata) = metadata.as_mut() {- metadata.remove(GUARDIAN_TICKET_METADATA_KEY);- if endpoint != ResponsesEndpoint::Responses {- metadata.remove("guardian_ticket_requested");- }- }- if endpoint != ResponsesEndpoint::Responses- && let Some(ticket) = ticket- {- metadata.get_or_insert_with(HashMap::new).insert(- GUARDIAN_TICKET_METADATA_KEY.to_owned(),- ticket.as_str().to_owned(),- );- }-}--#[cfg(test)]-#[path = "guardian_ticket_tests.rs"]-mod tests;diff --git a/codex-rs/codex-api/src/guardian_ticket_tests.rs b/codex-rs/codex-api/src/guardian_ticket_tests.rsdeleted file mode 100644index ba7307f703..0000000000--- a/codex-rs/codex-api/src/guardian_ticket_tests.rs+++ /dev/null@@ -1,60 +0,0 @@-use super::*;-use crate::common::ResponseEvent;-use crate::sse::responses::ResponsesStreamEvent;-use crate::sse::responses::process_responses_event;-use pretty_assertions::assert_eq;-use serde_json::json;--#[test]-fn response_created_receipt_is_runtime_only_and_redacted() {- let raw = "a".repeat(43);- let event: ResponsesStreamEvent = serde_json::from_value(json!({- "type": "response.created",- "response": {"id": "resp-1", "headers": {"x-codex-guardian-ticket": raw}}- }))- .unwrap();- let ResponseEvent::Created { guardian_ticket } =- process_responses_event(event).unwrap().unwrap()- else {- panic!("expected response.created");- };- let ticket = guardian_ticket.unwrap();- assert_eq!(ticket.as_str(), raw);- assert!(!format!("{ticket:?}").contains(&raw));- let mut metadata = Some(HashMap::from([("turn_id".into(), "turn-1".into())]));- attach(&mut metadata, Some(&ticket), ResponsesEndpoint::Guardian);- assert_eq!(- metadata,- Some(HashMap::from([- ("turn_id".into(), "turn-1".into()),- (GUARDIAN_TICKET_METADATA_KEY.into(), raw),- ]))- );- attach(- &mut metadata,- /*ticket*/ None,- ResponsesEndpoint::Guardian,- );- assert_eq!(- metadata,- Some(HashMap::from([("turn_id".into(), "turn-1".into())]))- );-}--#[test]-fn missing_or_malformed_response_receipts_do_not_become_tickets() {- for response in [- json!({}),- json!({"headers": {"x-codex-guardian-ticket": "invalid"}}),- ] {- let event =- serde_json::from_value(json!({"type": "response.created", "response": response}))- .unwrap();- assert!(matches!(- process_responses_event(event).unwrap(),- Some(ResponseEvent::Created {- guardian_ticket: None- })- ));- }-}diff --git a/codex-rs/codex-api/src/lib.rs b/codex-rs/codex-api/src/lib.rsindex a302c2595f..7287cb29d2 100644--- a/codex-rs/codex-api/src/lib.rs+++ b/codex-rs/codex-api/src/lib.rs@@ -4,7 +4,6 @@ pub(crate) mod common;pub(crate) mod endpoint;pub(crate) mod error;pub(crate) mod files;-mod guardian_ticket;pub(crate) mod images;pub(crate) mod provider;pub(crate) mod rate_limits;@@ -40,6 +39,7 @@ pub use crate::common::ReasoningContext;pub use crate::common::ReasoningSummaryDelivery;pub use crate::common::ResponseCreateWsRequest;pub use crate::common::ResponseEvent;+pub use crate::common::ResponseId;pub use crate::common::ResponseStream;pub use crate::common::ResponsesApiRequest;pub use crate::common::ResponsesApiTools;diff --git a/codex-rs/codex-api/src/sse/responses.rs b/codex-rs/codex-api/src/sse/responses.rsindex 8f2c5f2fa8..68b6d663b8 100644--- a/codex-rs/codex-api/src/sse/responses.rs+++ b/codex-rs/codex-api/src/sse/responses.rs@@ -9,8 +9,6 @@ use crate::telemetry::SseTelemetry;use codex_client::ByteStream;use codex_client::StreamResponse;use codex_protocol::ResponseUsageMetadata;-use codex_protocol::guardian_ticket::GUARDIAN_TICKET_HEADER;-use codex_protocol::guardian_ticket::GuardianTicket;use codex_protocol::models::ResponseItem;use codex_protocol::protocol::MisalignmentErrorDetails;use codex_protocol::protocol::ModelVerification;@@ -409,17 +407,11 @@ pub fn process_responses_event(}"response.created" => {if let Some(response) = event.response {- let guardian_ticket = response- .get("headers")- .and_then(Value::as_object)- .and_then(|headers| {- headers- .iter()- .find(|(name, _)| name.eq_ignore_ascii_case(GUARDIAN_TICKET_HEADER))- })- .and_then(|(_, value)| value.as_str())- .and_then(GuardianTicket::from_server);- return Ok(Some(ResponseEvent::Created { guardian_ticket }));+ let response_id = response+ .get("id")+ .and_then(Value::as_str)+ .map(str::to_owned);+ return Ok(Some(ResponseEvent::Created { response_id }));}}"response.failed" => {@@ -1630,9 +1622,7 @@ mod tests {);assert_matches!(&events[1],- ResponseEvent::Created {- guardian_ticket: None- }+ ResponseEvent::Created { response_id: Some(id) } if id == "resp-1");assert_matches!(&events[2],diff --git a/codex-rs/codex-api/tests/clients.rs b/codex-rs/codex-api/tests/clients.rsindex 07c34b3ba5..af43022417 100644--- a/codex-rs/codex-api/tests/clients.rs+++ b/codex-rs/codex-api/tests/clients.rs@@ -331,8 +331,7 @@ async fn responses_client_uses_guardian_path() -> Result<()> {async fn responses_client_stream_request_preserves_item_ids() -> Result<()> {let state = RecordingState::default();let transport = RecordingTransport::new(state.clone());- let client = ResponsesClient::new(transport, provider("openai"), Arc::new(NoAuth))- .with_endpoint(ResponsesEndpoint::Guardian);+ let client = ResponsesClient::new(transport, provider("openai"), Arc::new(NoAuth));let request = ResponsesApiRequest {model: "gpt-test".into(),instructions: "Say hi".into(),@@ -357,24 +356,14 @@ async fn responses_client_stream_request_preserves_item_ids() -> Result<()> {client_metadata: None,access_programs: None,};- let raw_ticket = "t".repeat(43);- let ticket = codex_protocol::guardian_ticket::GuardianTicket::from_server(&raw_ticket).unwrap();- let mut expected = serde_json::to_value(&request)?;- expected["client_metadata"] = serde_json::json!({"guardian_ticket": raw_ticket});+ let expected = serde_json::to_value(&request)?;let _stream = client- .stream_request(- request,- ResponsesOptions {- guardian_ticket: Some(ticket),- ..Default::default()- },- )+ .stream_request(request, ResponsesOptions::default()).await?;let requests = state.take_stream_requests();assert_eq!(requests.len(), 1);- assert!(!format!("{:?}", requests[0]).contains(&raw_ticket));let prepared = requests[0].prepare_body_for_send().expect("body should prepare");@@ -589,7 +578,6 @@ async fn azure_store_sends_ids_and_headers() -> Result<()> {extra_headers,compression: Compression::None,turn_state: None,- guardian_ticket: None,},).await?;diff --git a/codex-rs/core/src/client.rs b/codex-rs/core/src/client.rsindex 9bef3b34cf..75ed0747ae 100644--- a/codex-rs/core/src/client.rs+++ b/codex-rs/core/src/client.rs@@ -1104,14 +1104,24 @@ impl ModelClient {&& provider.aws.is_none()}- fn set_guardian_ticket_request(+ fn set_guardian_metadata(&self,metadata: &mut Option<HashMap<String, String>>,+ parent_response_id: Option<&str>,auth: Option<&CodexAuth>,endpoint: ResponsesEndpoint,) {if let Some(metadata) = metadata.as_mut() {- metadata.remove("guardian_ticket_requested");+ metadata.remove("guardian_credits_requested");+ metadata.remove("parent_response_id");+ }+ if endpoint == ResponsesEndpoint::Guardian+ && let Some(parent_response_id) = parent_response_id+ {+ metadata.get_or_insert_with(HashMap::new).insert(+ "parent_response_id".to_owned(),+ parent_response_id.to_owned(),+ );}if self.free_guardian_enabled&& endpoint == ResponsesEndpoint::Responses@@ -1125,7 +1135,7 @@ impl ModelClient {{metadata.get_or_insert_with(HashMap::new)- .insert("guardian_ticket_requested".to_owned(), "true".to_owned());+ .insert("guardian_credits_requested".to_owned(), "true".to_owned());}}@@ -1351,7 +1361,6 @@ impl ModelClientSession {},compression,turn_state: Some(Arc::clone(&self.turn_state)),- guardian_ticket: responses_metadata.guardian_ticket.clone(),}}@@ -1641,8 +1650,9 @@ impl ModelClientSession {service_tier.clone(),responses_metadata,)?;- self.client.set_guardian_ticket_request(+ self.client.set_guardian_metadata(&mut request.client_metadata,+ responses_metadata.parent_response_id.as_deref(),client_setup.auth.as_ref(),endpoint,);@@ -1900,8 +1910,9 @@ impl ModelClientSession {),..ResponseCreateWsRequest::from(&request)};- self.client.set_guardian_ticket_request(+ self.client.set_guardian_metadata(&mut ws_payload.client_metadata,+ responses_metadata.parent_response_id.as_deref(),client_setup.auth.as_ref(),endpoint,);@@ -1922,7 +1933,6 @@ impl ModelClientSession {ws_request,self.websocket_session.connection_reused(),Some(Arc::clone(&self.turn_state)),- responses_metadata.guardian_ticket.as_ref(),).await;if let Some(original_item_ids) = original_item_ids {diff --git a/codex-rs/core/src/client_tests.rs b/codex-rs/core/src/client_tests.rsindex ba97459c49..348d169c69 100644--- a/codex-rs/core/src/client_tests.rs+++ b/codex-rs/core/src/client_tests.rs@@ -844,9 +844,7 @@ async fn response_stream_records_last_model_feedback_ids() {.set_default();let api_stream = futures::stream::iter([- Ok(ResponseEvent::Created {- guardian_ticket: None,- }),+ Ok(ResponseEvent::Created { response_id: None }),Ok(ResponseEvent::Completed {response_id: "resp-123".to_string(),token_usage: None,@@ -1062,9 +1060,7 @@ async fn dropped_backpressured_response_stream_traces_cancelled_partial_output()let backpressured_item_yielded = Arc::new(Notify::new());let mut events = VecDeque::new();for _ in 0..super::RESPONSE_STREAM_CHANNEL_CAPACITY {- events.push_back(ResponseEvent::Created {- guardian_ticket: None,- });+ events.push_back(ResponseEvent::Created { response_id: None });}events.push_back(ResponseEvent::OutputItemDone(output_message("1",diff --git a/codex-rs/core/src/guardian/mod.rs b/codex-rs/core/src/guardian/mod.rsindex 86e71bfd6f..57fdcd7737 100644--- a/codex-rs/core/src/guardian/mod.rs+++ b/codex-rs/core/src/guardian/mod.rs@@ -88,8 +88,8 @@ const GUARDIAN_RECENT_ENTRY_LIMIT: usize = 40;/// step-scoped things past their lifetime (like MCP bindings)#[derive(Clone)]pub(crate) struct GuardianReviewContext {- /// Ticket from the response currently handled in this execution context.- pub(crate) guardian_ticket: Option<codex_protocol::guardian_ticket::GuardianTicket>,+ /// The response currently handled in this execution context.+ pub(crate) parent_response_id: Option<String>,turn: Arc<TurnContext>,environments: TurnEnvironmentSnapshot,// Model and reasoning inputs are carried for the follow-up Guardian and V2 migrations.@@ -109,11 +109,10 @@ impl GuardianReviewContext {settings: &ResolvedStepSettings,) -> Self {Self {- guardian_ticket: turn+ parent_response_id: turn.extension_data- .get::<codex_protocol::guardian_ticket::GuardianTicket>()- .as_deref()- .cloned(),+ .get::<codex_api::ResponseId>()+ .map(|id| id.0.clone()),environments: turn.environments.clone(),model_info: Arc::clone(&settings.model_info),reasoning_effort: settings.reasoning_effort().cloned(),@@ -136,12 +135,11 @@ impl GuardianReviewContext {impl From<&Arc<StepContext>> for GuardianReviewContext {fn from(step: &Arc<StepContext>) -> Self {Self {- guardian_ticket: step+ parent_response_id: step.turn.extension_data- .get::<codex_protocol::guardian_ticket::GuardianTicket>()- .as_deref()- .cloned(),+ .get::<codex_api::ResponseId>()+ .map(|id| id.0.clone()),turn: Arc::clone(&step.turn),environments: step.environments.clone(),model_info: Arc::clone(&step.settings.model_info),@@ -156,11 +154,10 @@ impl From<&Arc<StepContext>> for GuardianReviewContext {impl From<Arc<TurnContext>> for GuardianReviewContext {fn from(turn: Arc<TurnContext>) -> Self {Self {- guardian_ticket: turn+ parent_response_id: turn.extension_data- .get::<codex_protocol::guardian_ticket::GuardianTicket>()- .as_deref()- .cloned(),+ .get::<codex_api::ResponseId>()+ .map(|id| id.0.clone()),environments: turn.environments.clone(),model_info: Arc::clone(turn.model_info()),reasoning_effort: turn.reasoning_effort().cloned(),diff --git a/codex-rs/core/src/guardian/review_session.rs b/codex-rs/core/src/guardian/review_session.rsindex f3a7a26146..3e99448917 100644--- a/codex-rs/core/src/guardian/review_session.rs+++ b/codex-rs/core/src/guardian/review_session.rs@@ -1300,8 +1300,14 @@ async fn run_review_on_session(}),..Default::default()})+ .with_responses_metadata(+ params+ .parent_context+ .parent_response_id+ .as_ref()+ .map(|id| HashMap::from([("parent_response_id".to_owned(), id.clone())])),+ ).on_start(TurnStartOptions {- guardian_ticket: params.parent_context.guardian_ticket.clone(),final_output_json_schema: Some(params.schema.clone()),service_tier: None,parent_turn_id: Some(parent_turn.sub_id.clone()),diff --git a/codex-rs/core/src/responses_metadata.rs b/codex-rs/core/src/responses_metadata.rsindex 8edfbdfc7a..3c1fd729fb 100644--- a/codex-rs/core/src/responses_metadata.rs+++ b/codex-rs/core/src/responses_metadata.rs@@ -58,8 +58,7 @@ pub(crate) const WORKSPACES_KEY: &str = "workspaces";// App-server clients can specify additional metadata in the `responsesapi_client_metadata` param// when submitting a turn, but they must not override fields owned by core.const RESERVED_METADATA_KEYS: &[&str] = &[- codex_protocol::guardian_ticket::GUARDIAN_TICKET_METADATA_KEY,- "guardian_ticket_requested",+ "guardian_credits_requested",INSTALLATION_ID_KEY,X_CODEX_INSTALLATION_ID_HEADER,SESSION_ID_KEY,@@ -219,8 +218,8 @@ pub(crate) enum TurnToolSource {/// truth.#[derive(Clone, Debug)]pub struct CodexResponsesMetadata {- /// Opaque runtime receipt; deliberately omitted from metadata projections.- pub(crate) guardian_ticket: Option<codex_protocol::guardian_ticket::GuardianTicket>,+ /// Guardian parent reference; projected only onto a Guardian request.+ pub(crate) parent_response_id: Option<String>,pub(crate) installation_id: String,pub(crate) session_id: String,pub(crate) thread_id: String,@@ -260,7 +259,7 @@ impl CodexResponsesMetadata {window_id: String,) -> Self {Self {- guardian_ticket: None,+ parent_response_id: None,installation_id,session_id,thread_id,diff --git a/codex-rs/core/src/session/review.rs b/codex-rs/core/src/session/review.rsindex 695662914a..8f14a5646d 100644--- a/codex-rs/core/src/session/review.rs+++ b/codex-rs/core/src/session/review.rs@@ -137,7 +137,6 @@ pub(super) async fn spawn_review_thread(extension_data.insert(parent_turn_context.skills_snapshot().as_ref().clone());let review_turn_context = TurnContext {- guardian_ticket: None,sub_id: review_turn_id.clone(),trace_id: current_span_trace_id(),realtime_active: parent_turn_context.realtime_active,diff --git a/codex-rs/core/src/session/session.rs b/codex-rs/core/src/session/session.rsindex a2d070f547..29bda89d2d 100644--- a/codex-rs/core/src/session/session.rs+++ b/codex-rs/core/src/session/session.rs@@ -619,7 +619,6 @@ impl Session {request_kind,);CodexResponsesMetadata {- guardian_ticket: turn_context.guardian_ticket.clone(),window_number: Some(window_number),context_window_id: Some(context_window_id),history_ingest_requested: turn_contextdiff --git a/codex-rs/core/src/session/turn.rs b/codex-rs/core/src/session/turn.rsindex 1482e540fe..fe99a18a2b 100644--- a/codex-rs/core/src/session/turn.rs+++ b/codex-rs/core/src/session/turn.rs@@ -1437,10 +1437,10 @@ async fn run_sampling_request(let mut original_input = None;let mut executed_tool_calls_by_output = HashMap::new();loop {- // A retry must not lend a previous response's ticket to the next tool call.+ // A retry must not attribute the next tool call to the previous response.turn_context.extension_data- .remove::<codex_protocol::guardian_ticket::GuardianTicket>();+ .remove::<codex_api::ResponseId>();let prompt_input = if let Some(input) = initial_input.take() {input} else {@@ -2376,9 +2376,11 @@ async fn try_run_sampling_request(record_turn_ttft_metric(&turn_context, &event).await;match event {- ResponseEvent::Created { guardian_ticket } => {- if let Some(ticket) = guardian_ticket {- turn_context.extension_data.insert(ticket);+ ResponseEvent::Created { response_id } => {+ if let Some(response_id) = response_id {+ turn_context+ .extension_data+ .insert(codex_api::ResponseId(response_id));}}ResponseEvent::OutputItemDone(mut item) => {diff --git a/codex-rs/core/src/session/turn_context.rs b/codex-rs/core/src/session/turn_context.rsindex 08a5bcf930..8df4f1cab6 100644--- a/codex-rs/core/src/session/turn_context.rs+++ b/codex-rs/core/src/session/turn_context.rs@@ -185,7 +185,6 @@ impl std::fmt::Debug for TurnEnvironment {/// Request options for one turn, separate from persistent thread settings.#[derive(Default)]pub(crate) struct NewTurnContextOptions {- pub(crate) guardian_ticket: Option<codex_protocol::guardian_ticket::GuardianTicket>,pub(crate) final_output_json_schema: Option<Value>,pub(crate) cyber_access_program: Option<CyberAccessProgram>,}@@ -193,8 +192,6 @@ pub(crate) struct NewTurnContextOptions {/// The context needed for a single turn of the thread.#[derive(Debug)]pub struct TurnContext {- /// Receipt selected for this Guardian turn, separate from its own responses.- pub(crate) guardian_ticket: Option<codex_protocol::guardian_ticket::GuardianTicket>,pub(crate) sub_id: String,pub(crate) trace_id: Option<String>,pub(crate) realtime_active: bool,@@ -540,7 +537,6 @@ impl TurnContext {windows_sandbox_level: self.windows_sandbox_level,available_models,unified_exec_shell_mode: self.unified_exec_shell_mode.clone(),- guardian_ticket: self.guardian_ticket.clone(),final_output_json_schema: self.final_output_json_schema.clone(),dynamic_tools: self.dynamic_tools.clone(),turn_metadata_state: self.turn_metadata_state.clone(),@@ -785,7 +781,6 @@ impl Session {let extension_data = Arc::new(codex_extension_api::ExtensionData::new(sub_id.clone()));extension_data.insert(skills_snapshot);TurnContext {- guardian_ticket: None,sub_id,trace_id: current_span_trace_id(),realtime_active: false,@@ -1040,7 +1035,6 @@ impl Session {turn_context.extension_data.insert(trusted_plugin_roots);turn_context.realtime_active = self.conversation.running_state().await.is_some();- turn_context.guardian_ticket = options.guardian_ticket;turn_context.final_output_json_schema = options.final_output_json_schema;if turn_context.config.model_provider_id == codex_model_provider_info::OPENAI_PROVIDER_ID {turn_context.cyber_access_program = options.cyber_access_program;diff --git a/codex-rs/core/src/session/turn_input.rs b/codex-rs/core/src/session/turn_input.rsindex 4bb8a16cfc..b064e24566 100644--- a/codex-rs/core/src/session/turn_input.rs+++ b/codex-rs/core/src/session/turn_input.rs@@ -121,7 +121,6 @@ impl PreparedTurnInputSettings {kind: TurnStartKind,) -> CodexResult<Option<Arc<TurnContext>>> {let TurnStartOptions {- guardian_ticket,turn_trigger,final_output_json_schema,service_tier,@@ -139,7 +138,6 @@ impl PreparedTurnInputSettings {updates.service_tier_for_turn = service_tier;let options = NewTurnContextOptions {- guardian_ticket,final_output_json_schema,cyber_access_program,};diff --git a/codex-rs/core/src/tasks/mod.rs b/codex-rs/core/src/tasks/mod.rsindex 9344f8262f..d976a0ea29 100644--- a/codex-rs/core/src/tasks/mod.rs+++ b/codex-rs/core/src/tasks/mod.rs@@ -473,7 +473,6 @@ impl Session {.new_turn_with_default_settings(sub_id,NewTurnContextOptions {- guardian_ticket: start_options.guardian_ticket,final_output_json_schema: start_options.final_output_json_schema,cyber_access_program: start_options.cyber_access_program,},diff --git a/codex-rs/core/src/turn_metadata.rs b/codex-rs/core/src/turn_metadata.rsindex 681475b86e..92afc9d9e1 100644--- a/codex-rs/core/src/turn_metadata.rs+++ b/codex-rs/core/src/turn_metadata.rs@@ -393,6 +393,14 @@ impl TurnMetadataState {.read().unwrap_or_else(std::sync::PoisonError::into_inner).clone();+ // Extract Guardian's internal parent before filtering configured metadata keys.+ // Ordinary app-server client metadata stays in `extra`.+ let parent_response_id =+ if self.subagent_header.as_deref() == Some(crate::guardian::GUARDIAN_REVIEWER_NAME) {+ extra.remove("parent_response_id")+ } else {+ None+ };for key in self.responses_api_metadata.read()@@ -402,6 +410,7 @@ impl TurnMetadataState {extra.remove(key);}let mut metadata = CodexResponsesMetadata {+ parent_response_id,turn_id: Some(self.turn_id.clone()),agent_name: Some(self.agent_name.clone()),forked_from_thread_id: self.forked_from_thread_id,diff --git a/codex-rs/core/src/turn_timing_tests.rs b/codex-rs/core/src/turn_timing_tests.rsindex ed79be2cd5..6b6cd8ac38 100644--- a/codex-rs/core/src/turn_timing_tests.rs+++ b/codex-rs/core/src/turn_timing_tests.rs@@ -29,9 +29,7 @@ async fn turn_timing_state_records_ttft_only_once_per_turn() {state.mark_turn_started(Instant::now()).await;assert_eq!(state- .record_ttft_for_response_event(&ResponseEvent::Created {- guardian_ticket: None- })+ .record_ttft_for_response_event(&ResponseEvent::Created { response_id: None }).await,None);diff --git a/codex-rs/core/tests/suite/code_mode.rs b/codex-rs/core/tests/suite/code_mode.rsindex e1ce2c5b73..b7c6b3c1b9 100644--- a/codex-rs/core/tests/suite/code_mode.rs+++ b/codex-rs/core/tests/suite/code_mode.rs@@ -2373,21 +2373,21 @@ async fn code_mode_wait_timeout_reconnects_on_next_exec() -> Result<()> {}#[derive(Default)]-struct GuardianTicketObserver {- tickets: Mutex<Vec<(String, Option<String>)>>,+struct ResponseIdObserver {+ response_ids: Mutex<Vec<(String, Option<String>)>>,wait_started: tokio::sync::Notify,}-impl ToolLifecycleContributor for GuardianTicketObserver {+impl ToolLifecycleContributor for ResponseIdObserver {fn on_tool_start<'a>(&'a self, input: ToolStartInput<'a>) -> ToolLifecycleFuture<'a> {Box::pin(async move {if matches!(input.tool_name.name.as_str(), "exec_command" | "wait") {- self.tickets.lock().unwrap().push((+ self.response_ids.lock().unwrap().push((input.tool_name.name.clone(),input.turn_store- .get::<codex_protocol::guardian_ticket::GuardianTicket>()- .map(|ticket| ticket.as_str().to_owned()),+ .get::<codex_api::ResponseId>()+ .map(|id| id.0.clone()),));if input.tool_name.name == "wait" {self.wait_started.notify_one();@@ -2403,7 +2403,7 @@ async fn code_mode_can_yield_and_resume_with_wait() -> Result<()> {skip_if_no_network!(Ok(()));let server = responses::start_mock_server().await;- let observer = Arc::new(GuardianTicketObserver::default());+ let observer = Arc::new(ResponseIdObserver::default());let mut extensions = ExtensionRegistryBuilder::<Config>::new();extensions.tool_lifecycle_contributor(observer.clone());let mut builder = test_codex()@@ -2431,7 +2431,7 @@ text((await tools.exec_command({{cmd: "printf 'phase 3'"}})).output);responses::mount_sse_once(&server,sse(vec![- serde_json::json!({"type": "response.created", "response": {"id": "resp-1", "headers": {"x-codex-guardian-ticket": "p".repeat(43)}}}),+ responses::ev_response_created("resp-1"),ev_custom_tool_call("call-1", "exec", &code),ev_completed("resp-1"),]),@@ -2464,7 +2464,7 @@ text((await tools.exec_command({{cmd: "printf 'phase 3'"}})).output);responses::mount_sse_once(&server,sse(vec![- serde_json::json!({"type": "response.created", "response": {"id": "resp-3", "headers": {"x-codex-guardian-ticket": "q".repeat(43)}}}),+ responses::ev_response_created("resp-3"),responses::ev_function_call("call-2","wait",@@ -2511,7 +2511,7 @@ text((await tools.exec_command({{cmd: "printf 'phase 3'"}})).output);responses::mount_sse_once(&server,sse(vec![- serde_json::json!({"type": "response.created", "response": {"id": "resp-5", "headers": {"x-codex-guardian-ticket": "r".repeat(43)}}}),+ responses::ev_response_created("resp-5"),responses::ev_function_call("call-3","wait",@@ -2551,15 +2551,18 @@ text((await tools.exec_command({{cmd: "printf 'phase 3'"}})).output););assert_eq!(text_item(&third_items, /*index*/ 1), "phase 3");- let observed = observer.tickets.lock().unwrap();- let mut nested_tickets = observed+ let observed = observer.response_ids.lock().unwrap();+ let mut nested_response_ids = observed.iter().filter(|(tool, _)| tool == "exec_command")- .filter_map(|(_, ticket)| ticket.clone())- .skip_while(|ticket| ticket != &"q".repeat(43))+ .filter_map(|(_, response_id)| response_id.clone())+ .skip_while(|response_id| response_id != &"resp-3".to_owned()).collect::<Vec<_>>();- nested_tickets.dedup();- assert_eq!(nested_tickets, vec!["q".repeat(43), "r".repeat(43)]);+ nested_response_ids.dedup();+ assert_eq!(+ nested_response_ids,+ vec!["resp-3".to_owned(), "resp-5".to_owned()]+ );assert_eq!(observed.iter()@@ -2567,8 +2570,8 @@ text((await tools.exec_command({{cmd: "printf 'phase 3'"}})).output);.cloned().collect::<Vec<_>>(),vec![- ("wait".to_owned(), Some("q".repeat(43))),- ("wait".to_owned(), Some("r".repeat(43))),+ ("wait".to_owned(), Some("resp-3".to_owned())),+ ("wait".to_owned(), Some("resp-5".to_owned())),]);Ok(())diff --git a/codex-rs/core/tests/suite/guardian_review.rs b/codex-rs/core/tests/suite/guardian_review.rsindex fe0a7aaa83..63a7aabd75 100644--- a/codex-rs/core/tests/suite/guardian_review.rs+++ b/codex-rs/core/tests/suite/guardian_review.rs@@ -135,14 +135,14 @@ impl TimeProvider for RecordingTimeProvider {#[test_case(CodexAuth::create_dummy_chatgpt_auth_for_testing(), "OpenAI", "/backend-api/codex", true, "/backend-api/codex/guardian", true; "chatgpt_uses_guardian_when_enabled")]#[test_case(CodexAuth::create_dummy_chatgpt_auth_for_testing(), "OpenAI", "/v1", true, "/v1/responses", true; "custom_openai_url_uses_responses")]#[test_case(CodexAuth::create_dummy_chatgpt_auth_for_testing(), "Custom", "/backend-api/codex", true, "/backend-api/codex/responses", true; "custom_provider_uses_responses")]-#[test_case(CodexAuth::create_dummy_chatgpt_auth_for_testing(), "OpenAI", "/backend-api/codex", true, "/backend-api/codex/guardian", false; "server_without_tickets")]+#[test_case(CodexAuth::create_dummy_chatgpt_auth_for_testing(), "OpenAI", "/backend-api/codex", true, "/backend-api/codex/guardian", false; "server_without_response_id")]async fn guardian_session_inherits_parent_http_fallback(auth: CodexAuth,provider_name: &str,base_path: &str,free_guardian: bool,expected_guardian_path: &str,- ticket_issued: bool,+ response_id_present: bool,) -> Result<()> {skip_if_no_network!(Ok(()));@@ -154,16 +154,16 @@ async fn guardian_session_inherits_parent_http_fallback(.mount_as_scoped(&server).await;- let parent_ticket = "p".repeat(43);+ let parent_response_id = "parent-tool";let responses = mount_sse_sequence(&server,vec![- // A failed sampling attempt must not lend its receipt to the retried action.+ // A failed sampling attempt must not supply the retried action's parent ID.sse(vec![json!({"type": "response.created", "response": {- "id": "failed-parent", "headers": {"x-codex-guardian-ticket": "f".repeat(43)}+ "id": "failed-parent"}})]),sse(vec![- json!({"type": "response.created", "response": {"id": "parent-tool", "headers": ticket_issued.then(|| json!({"x-codex-guardian-ticket": parent_ticket}))}}),+ json!({"type": "response.created", "response": {"id": response_id_present.then_some(parent_response_id)}}),ev_function_call("call","exec_command",@@ -241,30 +241,30 @@ async fn guardian_session_inherits_parent_http_fallback(}).expect("Guardian reviewer inference request");assert_eq!(guardian_request.path(), expected_guardian_path);- let tickets_enabled = expected_guardian_path.ends_with("/guardian");+ let credits_enabled = expected_guardian_path.ends_with("/guardian");let body = guardian_request.body_json();assert_eq!((- body["client_metadata"].get("guardian_ticket").cloned(),- body["client_metadata"].get("guardian_ticket_requested"),+ body["client_metadata"].get("parent_response_id").cloned(),+ body["client_metadata"].get("guardian_credits_requested"),),(- (tickets_enabled && ticket_issued).then(|| json!(parent_ticket)),+ (credits_enabled && response_id_present).then(|| json!(parent_response_id)),None));- assert!(!body["input"].to_string().contains(&parent_ticket));+ assert!(!body["input"].to_string().contains(parent_response_id));for request in responses.requests() {let body = request.body_json();if body["client_metadata"]["x-openai-subagent"] != "guardian" {assert_eq!((body["client_metadata"]- .get("guardian_ticket_requested")+ .get("guardian_credits_requested").cloned(),- body["client_metadata"].get("guardian_ticket"),+ body["client_metadata"].get("parent_response_id"),),- (tickets_enabled.then(|| json!("true")), None)+ (credits_enabled.then(|| json!("true")), None));}}@@ -409,7 +409,7 @@ async fn guardian_session_prewarms_and_is_reused_for_first_review(skip_if_no_network!(Ok(()));let uses_codex_backend = auth.uses_codex_backend();- let tickets_enabled = free_guardian && uses_codex_backend;+ let credits_enabled = free_guardian && uses_codex_backend;let bundled_models = codex_models_manager::bundled_models_response()?.models;let catalog_auto_review = bundled_models.iter()@@ -442,12 +442,12 @@ async fn guardian_session_prewarms_and_is_reused_for_first_review("justification": "Exercise Guardian approval routing.",}).to_string();- let parent_ticket = "w".repeat(43);+ let parent_response_id = "approval-request";let server = start_websocket_server(vec![vec![vec![ev_response_created("warm-1"), ev_completed("warm-1")]],vec![vec![ev_response_created("warm-2"), ev_completed("warm-2")]],vec![vec![- json!({"type": "response.created", "response": {"id": "approval-request", "headers": {"x-codex-guardian-ticket": parent_ticket}}}),+ ev_response_created(parent_response_id),ev_function_call("approval-call", "exec_command", &tool_args),ev_completed("approval-request"),]],@@ -603,30 +603,30 @@ async fn guardian_session_prewarms_and_is_reused_for_first_review(assert_eq!((guardian_review["client_metadata"]- .get("guardian_ticket")+ .get("parent_response_id").cloned(),- guardian_review["client_metadata"].get("guardian_ticket_requested"),+ guardian_review["client_metadata"].get("guardian_credits_requested"),parent_request["client_metadata"]- .get("guardian_ticket_requested")+ .get("guardian_credits_requested").cloned(),- parent_request["client_metadata"].get("guardian_ticket"),+ parent_request["client_metadata"].get("parent_response_id"),),(- tickets_enabled.then(|| json!(parent_ticket)),+ credits_enabled.then(|| json!(parent_response_id)),None,- tickets_enabled.then(|| json!("true")),+ credits_enabled.then(|| json!("true")),None,));assert!(guardian_prewarm["client_metadata"]- .get("guardian_ticket")+ .get("parent_response_id").is_none());assert!(!guardian_review["input"].to_string()- .contains(&parent_ticket)+ .contains(parent_response_id));for request in [&parent_request, &guardian_review] {assert_root_turn(request, Some(parent_turn_id))?;@@ -710,7 +710,7 @@ async fn guardian_session_prewarms_and_is_reused_for_first_review(assert_eq!(guardian_context_windows, vec![Some(258_400)]);for handshake in server.handshakes() {let is_guardian = handshake.header("x-openai-subagent").as_deref() == Some("guardian");- let uses_guardian_endpoint = tickets_enabled && is_guardian;+ let uses_guardian_endpoint = credits_enabled && is_guardian;assert_eq!(handshake.uri(),if uses_guardian_endpoint {diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/extension.rs b/codex-rs/ext/guardian-v2/src/async_scorer/extension.rsindex cd0723fe17..376a8dca04 100644--- a/codex-rs/ext/guardian-v2/src/async_scorer/extension.rs+++ b/codex-rs/ext/guardian-v2/src/async_scorer/extension.rs@@ -512,11 +512,10 @@ impl GuardianV2Extension {let thread_id = input.thread_store.level_id().to_owned();let turn_id = input.turn_id.to_owned();let root_turn_id = input.root_turn_id.map(str::to_owned);- let guardian_ticket = input+ let parent_response_id = input.turn_store- .get::<codex_protocol::guardian_ticket::GuardianTicket>()- .as_deref()- .cloned();+ .get::<codex_api::ResponseId>()+ .map(|id| id.0.clone());let thread_context: Result<_, String> = async {let parsed_thread_id =ThreadId::from_string(&thread_id).map_err(|error| error.to_string())?;@@ -839,7 +838,7 @@ impl GuardianV2Extension {let instructions = guardian_config.render_classifier_instructions(policy);let output = match sampler.sample(LunaSamplingRequest {- guardian_ticket,+ parent_response_id,instructions,trusted_review_evidence,trusted_tool_context,diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/sampler.rs b/codex-rs/ext/guardian-v2/src/async_scorer/sampler.rsindex f2b7bcc14b..33472a82eb 100644--- a/codex-rs/ext/guardian-v2/src/async_scorer/sampler.rs+++ b/codex-rs/ext/guardian-v2/src/async_scorer/sampler.rs@@ -90,8 +90,8 @@ pub struct LunaSamplerConfig {/// One tool-less Luna classification request over an already-open connection.pub struct LunaSamplingRequest {- /// Runtime receipt of the response handling the classified tool.- pub guardian_ticket: Option<codex_protocol::guardian_ticket::GuardianTicket>,+ /// ID of the response handling the classified tool.+ pub parent_response_id: Option<String>,/// Trusted instructions describing the requested classification.pub instructions: String,/// Host-supplied Guardian reviews isolated from untrusted transcript entries.@@ -454,7 +454,7 @@ impl LunaSampler {}// A classification is its own inference turn; retries keep that identity.let turn_id = Uuid::now_v7().to_string();- let guardian_ticket = request.guardian_ticket;+ let parent_response_id = request.parent_response_id;let parent_turn_id = request.parent_turn_id;let root_turn_id = request.root_turn_id;let mut input = vec![@@ -629,6 +629,11 @@ impl LunaSampler {turn_metadata["root_turn_id"] = json!(root_turn_id);}client_metadata.insert(TURN_METADATA_KEY.to_owned(), turn_metadata.to_string());+ if lease.connection.endpoint == ResponsesEndpoint::GuardianClassifier+ && let Some(parent_response_id) = &parent_response_id+ {+ client_metadata.insert("parent_response_id".to_owned(), parent_response_id.clone());+ }request.client_metadata = Some(client_metadata);let mut stream = match lease.connection@@ -637,7 +642,6 @@ impl LunaSampler {ResponsesWsRequest::ResponseCreate((&request).into()),/*connection_reused*/ true,/*turn_state*/ None,- guardian_ticket.as_ref(),).await{diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/sampler_tests.rs b/codex-rs/ext/guardian-v2/src/async_scorer/sampler_tests.rsindex 4d61c61fe5..87028cc1e9 100644--- a/codex-rs/ext/guardian-v2/src/async_scorer/sampler_tests.rs+++ b/codex-rs/ext/guardian-v2/src/async_scorer/sampler_tests.rs@@ -192,7 +192,7 @@ async fn connect_sampler(config: LunaSamplerConfig) -> Result<LunaSampler> {fn sample_request(parent_turn_id: &str) -> LunaSamplingRequest {LunaSamplingRequest {- guardian_ticket: None,+ parent_response_id: None,instructions: "Return high for high risk or low for low risk.".to_owned(),trusted_review_evidence: Vec::new(),trusted_tool_context: None,@@ -447,7 +447,7 @@ async fn preconnected_sampler_reuses_authenticated_websocket_for_classificationslet first = sampler.sample(LunaSamplingRequest {- guardian_ticket: None,+ parent_response_id: None,instructions: "Return high for high risk or low for low risk.".to_owned(),trusted_review_evidence: Vec::new(),trusted_tool_context: None,@@ -479,7 +479,7 @@ async fn preconnected_sampler_reuses_authenticated_websocket_for_classificationsmanager.refresh_token_from_authority().await?;let second = sampler.sample(LunaSamplingRequest {- guardian_ticket: None,+ parent_response_id: None,instructions: "Return high for high risk or low for low risk.".to_owned(),trusted_review_evidence: Vec::new(),trusted_tool_context: None,@@ -655,7 +655,7 @@ async fn sampler_returns_classification_token_before_terminal_response_events()let output = tokio::time::timeout(Duration::from_secs(2),sampler.sample(LunaSamplingRequest {- guardian_ticket: None,+ parent_response_id: None,instructions: "Return high for high risk or low for low risk.".to_owned(),trusted_review_evidence: Vec::new(),trusted_tool_context: None,@@ -1119,7 +1119,7 @@ async fn sampler_limits_transient_recovery_attempts() -> Result<()> {}#[tokio::test(flavor = "multi_thread", worker_threads = 2)]-async fn guardian_ticket_survives_classifier_transport_retry() -> Result<()> {+async fn parent_response_id_survives_classifier_transport_retry() -> Result<()> {skip_if_no_network!(Ok(()));for free_guardian in [false, true] {let healthy = responses::start_websocket_server(vec![vec![vec![@@ -1146,10 +1146,9 @@ async fn guardian_ticket_survives_classifier_transport_retry() -> Result<()> {);}let sampler = connect_sampler(config).await?;- let raw_ticket = "t".repeat(43);+ let parent_response_id = "resp-parent";let mut request = sample_request("turn-1");- request.guardian_ticket =- codex_protocol::guardian_ticket::GuardianTicket::from_server(&raw_ticket);+ request.parent_response_id = Some(parent_response_id.to_owned());assert_eq!(sampler.sample(request).await?, "low");for server in [&expired, &healthy] {let requests = server.single_connection();@@ -1157,12 +1156,12 @@ async fn guardian_ticket_survives_classifier_transport_retry() -> Result<()> {let body = requests[0].body_json();assert_eq!((- body["client_metadata"].get("guardian_ticket").cloned(),- body["client_metadata"].get("guardian_ticket_requested"),+ body["client_metadata"].get("parent_response_id").cloned(),+ body["client_metadata"].get("guardian_credits_requested"),),- (free_guardian.then(|| json!(raw_ticket)), None)+ (free_guardian.then(|| json!(parent_response_id)), None));- assert!(!body["input"].to_string().contains(&raw_ticket));+ assert!(!body["input"].to_string().contains(parent_response_id));}}diff --git a/codex-rs/http-client/src/request.rs b/codex-rs/http-client/src/request.rsindex 84b9a730d9..7608860c3d 100644--- a/codex-rs/http-client/src/request.rs+++ b/codex-rs/http-client/src/request.rs@@ -11,7 +11,7 @@ use std::time::Duration;/// Clones share the encoded allocation. Internally, the body can also hold the/// final compressed wire bytes while retaining the original JSON only when/// request-body trace logging is enabled.-#[derive(Clone, PartialEq, Eq)]+#[derive(Debug, Clone, PartialEq, Eq)]pub struct EncodedJsonBody {bytes: Bytes,trace_bytes: Option<Bytes>,@@ -33,27 +33,11 @@ impl EncodedJsonBody {&self.bytes}- /// Omits credential-bearing bodies from tracing and debug output, including retries.- pub fn without_body_logging(mut self) -> Self {- self.trace_bytes = Some(Bytes::from_static(b"<redacted>"));- self- }-pub(crate) fn trace_bytes(&self) -> &[u8] {self.trace_bytes.as_ref().unwrap_or(&self.bytes)}}-impl std::fmt::Debug for EncodedJsonBody {- fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {- formatter- .debug_struct("EncodedJsonBody")- .field("body", &String::from_utf8_lossy(self.trace_bytes()))- .field("prepared", &self.prepared)- .finish()- }-}-#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]pub enum RequestCompression {#[default]@@ -136,13 +120,7 @@ impl Request {self.body,Some(RequestBody::Json(_) | RequestBody::EncodedJson(_)));- let retained_trace_bytes = match self.body.as_ref() {- Some(RequestBody::EncodedJson(body)) => body.trace_bytes.clone(),- Some(RequestBody::Json(_) | RequestBody::Raw(_)) | None => None,- };- let trace_bytes = if retained_trace_bytes.is_some() {- retained_trace_bytes- } else if self.compression != RequestCompression::None+ let trace_bytes = if self.compression != RequestCompression::None&& tracing::enabled!(target: "codex_http_client::transport", tracing::Level::TRACE){match self.body.as_ref() {diff --git a/codex-rs/http-client/src/transport_tests.rs b/codex-rs/http-client/src/transport_tests.rsindex 6f28df9025..a8ab11aba5 100644--- a/codex-rs/http-client/src/transport_tests.rs+++ b/codex-rs/http-client/src/transport_tests.rs@@ -1,7 +1,4 @@use super::*;-use crate::request::EncodedJsonBody;-use crate::request::RequestCompression;-use pretty_assertions::assert_eq;use serde_json::json;use std::io::Write;use std::sync::Arc;@@ -31,35 +28,6 @@ async fn disabled_request_logging_suppresses_transport_url_and_body() {assert!(!logs.contains("body-secret"));}-#[test]-fn sensitive_encoded_body_stays_redacted_after_preparation_and_retries() {- let payload = json!({"client_metadata": {"guardian_ticket": "secret-receipt"}});- for compression in [RequestCompression::None, RequestCompression::Zstd] {- let mut request = Request::new(Method::POST, "https://example.com/responses".into())- .with_compression(compression);- request.body = Some(RequestBody::EncodedJson(- EncodedJsonBody::encode(&payload)- .unwrap()- .without_body_logging(),- ));- assert_eq!(request_body_for_trace(&request), "<redacted>");- for _ in 0..2 {- request = request.clone().into_prepared().unwrap();- assert_eq!(request_body_for_trace(&request), "<redacted>");- assert!(!format!("{request:?}").contains("secret-receipt"));- let body = request.prepare_body_for_send().unwrap().body.unwrap();- let decoded = match compression {- RequestCompression::None => body.to_vec(),- RequestCompression::Zstd => zstd::stream::decode_all(body.as_ref()).unwrap(),- };- assert_eq!(- serde_json::from_slice::<serde_json::Value>(&decoded).unwrap(),- payload- );- }- }-}-#[tokio::test]async fn connection_failures_are_classified_without_exposing_request_urls() {let unavailable_server =diff --git a/codex-rs/protocol/src/guardian_ticket.rs b/codex-rs/protocol/src/guardian_ticket.rsdeleted file mode 100644index 942a463ae8..0000000000--- a/codex-rs/protocol/src/guardian_ticket.rs+++ /dev/null@@ -1,37 +0,0 @@-//! Opaque parent-inference receipts kept out of persisted and model-visible context.--use std::fmt;--/// Header carried on the parent response's metadata, for both SSE and WebSocket.-pub const GUARDIAN_TICKET_HEADER: &str = "x-codex-guardian-ticket";-/// Request metadata consumed by Codex backend before forwarding reviewer inference.-pub const GUARDIAN_TICKET_METADATA_KEY: &str = "guardian_ticket";--/// A server-issued receipt. Parsing checks its shape, not its authenticity.-///-/// Only the backend can validate ownership, expiry, and remaining allowance. This-/// type intentionally has no serialization implementation or unredacted Debug.-#[derive(Clone, PartialEq, Eq)]-pub struct GuardianTicket(String);--impl GuardianTicket {- /// Accept the bounded URL-safe representation used by the receipt issuer.- pub fn from_server(value: &str) -> Option<Self> {- (value.len() == 43- && value- .bytes()- .all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'-' | b'_')))- .then(|| Self(value.to_owned()))- }-- /// Expose the receipt only when writing transport metadata.- pub fn as_str(&self) -> &str {- &self.0- }-}--impl fmt::Debug for GuardianTicket {- fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {- formatter.write_str("GuardianTicket([REDACTED])")- }-}diff --git a/codex-rs/protocol/src/lib.rs b/codex-rs/protocol/src/lib.rsindex 80531f4586..10af9c7317 100644--- a/codex-rs/protocol/src/lib.rs+++ b/codex-rs/protocol/src/lib.rs@@ -25,7 +25,6 @@ pub mod dynamic_tools;mod environment;pub mod error;pub mod exec_output;-pub mod guardian_ticket;pub mod items;mod legacy_events;pub mod local_media;diff --git a/codex-rs/protocol/src/turn_input.rs b/codex-rs/protocol/src/turn_input.rsindex 2715fd61cf..4819d0fb9b 100644--- a/codex-rs/protocol/src/turn_input.rs+++ b/codex-rs/protocol/src/turn_input.rs@@ -158,8 +158,6 @@ pub enum CyberAccessProgram {/// child input, Core also compares root lineage to detect ambiguity.#[derive(Clone, Debug, Default)]pub struct TurnStartOptions {- /// Parent inference receipt for an internal Guardian turn. Never persisted.- pub guardian_ticket: Option<crate::guardian_ticket::GuardianTicket>,/// Source classification for the caller that starts a new turn./// Ignored when the submitted input steers an active turn.pub turn_trigger: Option<String>,