Replace Guardian tickets with parent response IDs (#43002)

## What changed

Capture the ID from `response.created` and pass it as `parent_response_id` in Guardian review and classifier request metadata. Clear the current response ID before sampling retries so tool reviews cannot inherit a failed response's ID.

Request Guardian credits with `guardian_credits_requested` on eligible parent requests. Remove the ticket protocol, transport attachment, and ticket-specific body redaction. Keep ordinary app-server client `parent_response_id` values inside `x-codex-turn-metadata` rather than promoting them to Guardian request metadata.

## Testing

Update coverage for HTTP fallback, WebSocket review reuse, missing response IDs, classifier transport retries, and code-mode yield/resume attribution. Extend app-server tests to verify client metadata placement over HTTP and WebSocket.

GitOrigin-RevId: c1665e56382ecec8d260fc2ca0ecd5e20b0b2391

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),

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 {

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();

codex-rs/codex-api/src/guardian_ticket.rs

@@ -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;

codex-rs/codex-api/src/guardian_ticket_tests.rs

@@ -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
-            })
-        ));
-    }
-}

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;

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],

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?;