Interrupt and drain canceled classifier responses before socket reuse (#53698)

## Why

Canceled classifier requests need bounded cleanup that preserves received token usage and returns only safe WebSocket connections to the pool.

## What changed

- Own classifier response streams and connection leases together, interrupting dropped responses with a one-second cleanup deadline.
- Require a matching interruption acknowledgement and response completion before reusing a canceled response's socket. Retire sockets on rejection, invalid acknowledgements, or timeout while preserving any received completion and token usage.
- Skip requests canceled before dispatch and return their unused sockets to the pool.
- Distinguish cancellation from ordinary steering, which continues draining without requiring an interruption acknowledgement.

## Testing

Add regression coverage for cancellation, acknowledgement ordering and failures, cleanup timeouts, socket reuse, and token accounting under backpressure. Extend steering tests to cover rejected and missing acknowledgements.

GitOrigin-RevId: c4e7aac49d36cea2c2d0e9f2ba5f6147f67471dd
This commit is contained in:
felixxia-oai
2026-10-13 15:24:00 +00:00
committed by copyberry
parent 31434401fa
commit ffc1402633
12 changed files with 466 additions and 49 deletions
+1 -1
View File
@@ -117,7 +117,7 @@ fn normalize_image_detail(detail: &mut Option<ImageDetail>, model_info: &ModelIn
pub struct ResponseStream {
pub(crate) rx_event: mpsc::Receiver<Result<ResponseEvent>>,
pub(crate) interrupt: Option<oneshot::Sender<()>>,
pub(crate) interrupt: Option<oneshot::Sender<codex_api::ResponseInterrupt>>,
/// Signals the mapper task that the consumer stopped polling before the
/// provider stream reached its own terminal event.
pub(crate) consumer_dropped: CancellationToken,
+1 -1
View File
@@ -2689,7 +2689,7 @@ async fn try_run_sampling_request(
Ok(Err(_)) => {
if let Some(interrupt) = stream.interrupt.take() {
if step_context.settings.model_info.use_responses_lite {
let _ = interrupt.send(());
let _ = interrupt.send(codex_api::ResponseInterrupt::Drain);
}
// Drain the response normally before reusing its connection and history.
preempt = CancellationToken::new();
+27 -15
View File
@@ -1239,16 +1239,23 @@ async fn injected_response_item_reopens_turn_after_final_answer() {
server.shutdown().await;
}
#[test_case(false; "completed_reasoning")]
#[test_case(true; "discarded_reasoning")]
#[test_case(false, Some("response.interrupt.accepted"); "completed_reasoning")]
#[test_case(true, Some("response.interrupt.accepted"); "discarded_reasoning")]
#[test_case(false, Some("response.interrupt.failed"); "rejected_interrupt")]
#[test_case(false, None; "missing_acknowledgement")]
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn steer_interrupts_and_drains_websocket(discard_partial: bool) -> anyhow::Result<()> {
async fn steer_interrupts_and_drains_websocket(
discard_partial: bool,
acknowledgement: Option<&str>,
) -> anyhow::Result<()> {
core_test_support::skip_if_no_network!(Ok(()));
let mut interrupted = ev_completed_with_tokens("resp-interrupted", /*total_tokens*/ 42);
interrupted["type"] = json!("response.incomplete");
interrupted["response"]["status"] = json!("incomplete");
interrupted["response"]["incomplete_details"] = json!({"reason": "interrupted"});
if acknowledgement == Some("response.interrupt.accepted") {
interrupted["type"] = json!("response.incomplete");
interrupted["response"]["status"] = json!("incomplete");
interrupted["response"]["incomplete_details"] = json!({"reason": "interrupted"});
}
let server = responses::start_websocket_server(vec![vec![
vec![ev_response_created("warm-1"), ev_completed("warm-1")],
vec![
@@ -1256,13 +1263,15 @@ async fn steer_interrupts_and_drains_websocket(discard_partial: bool) -> anyhow:
ev_reasoning_item_added("reason-1", &["thinking"]),
],
// Finish the active response only after receiving response.interrupt.
vec![
json!({
"type": "response.interrupt.accepted",
"response_id": "resp-interrupted",
"sequence_number": 3,
[
acknowledgement.map(|kind| {
json!({
"type": kind,
"response_id": "resp-interrupted",
"sequence_number": 3,
})
}),
if discard_partial {
Some(if discard_partial {
json!({
"type": "response.output_item.interrupted",
"response_id": "resp-interrupted",
@@ -1272,9 +1281,12 @@ async fn steer_interrupts_and_drains_websocket(discard_partial: bool) -> anyhow:
})
} else {
ev_reasoning_item("reason-1", &["thinking"], &[])
},
interrupted,
],
}),
Some(interrupted),
]
.into_iter()
.flatten()
.collect(),
vec![
ev_response_created("resp-follow-up"),
ev_completed("resp-follow-up"),