Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy
Rust
fix canceled codex continuations
Raine Virtac1ec2383605e
diff --git a/src/providers/codex/client.rs b/src/providers/codex/client.rsindex 07f7231..4bc5630 100644--- a/src/providers/codex/client.rs+++ b/src/providers/codex/client.rs@@ -296,7 +296,6 @@ impl CodexHttpClient {continuation: Option<&super::continuation::ContinuationCandidate>,transport: crate::config::CodexTransport,) -> Result<CodexResponse, CodexError> {- use super::continuation::clear_continuation;use crate::config::CodexTransport;let mut auth = self.auth_manager.get_auth().await.map_err(|e| CodexError {@@ -311,14 +310,18 @@ impl CodexHttpClient {if should_reset_websocket_pool(continuation)&& let Some(key) = initial_pool_key{- super::websocket::invalidate_codex_websocket_pool_key(key);+ super::websocket::invalidate_codex_websocket_pool_turn(+ key,+ continuation.and_then(|candidate| candidate.turn_id),+ );}- let mut active_continuation = continuation;+ let turn_id = continuation.and_then(|candidate| candidate.turn_id);+ let mut active_continuation = continuation.cloned();let mut auth_refresh_attempted = false;let mut transport_failures = 0u32;loop {- let pool_key = websocket_pool_key(ctx, active_continuation);+ let pool_key = websocket_pool_key(ctx, active_continuation.as_ref());let result = match transport {CodexTransport::Http => {let body_json = serde_json::to_string(body).map_err(|e| CodexError {@@ -335,7 +338,7 @@ impl CodexHttpClient {let ws_headers =build_codex_headers(&auth, ctx, body.client_metadata.is_some())?;let ws_headers = super::websocket::codex_websocket_headers(&ws_headers);- let ws_body = build_websocket_request(body, active_continuation);+ let ws_body = build_websocket_request(body, active_continuation.as_ref());super::websocket::codex_websocket_request(&self.base_url,@@ -346,7 +349,7 @@ impl CodexHttpClient {pool_key,super::websocket::WEBSOCKET_CONNECT_TIMEOUT_MS,super::websocket::WEBSOCKET_IDLE_TIMEOUT_MS,- active_continuation,+ active_continuation.as_ref(),).await}@@ -354,7 +357,7 @@ impl CodexHttpClient {let ws_headers =build_codex_headers(&auth, ctx, body.client_metadata.is_some())?;let ws_headers = super::websocket::codex_websocket_headers(&ws_headers);- let ws_body = build_websocket_request(body, active_continuation);+ let ws_body = build_websocket_request(body, active_continuation.as_ref());// Try WebSocket firstlet ws_result = super::websocket::codex_websocket_request(@@ -366,7 +369,7 @@ impl CodexHttpClient {pool_key,super::websocket::WEBSOCKET_CONNECT_TIMEOUT_MS,super::websocket::WEBSOCKET_IDLE_TIMEOUT_MS,- active_continuation,+ active_continuation.as_ref(),).await;@@ -401,8 +404,10 @@ impl CodexHttpClient {Ok(new_auth) => {auth = new_auth;if let Some(key) = pool_key {- super::websocket::invalidate_codex_websocket_pool_key(key);+ super::websocket::invalidate_codex_websocket_pool_turn(key, turn_id);}+ active_continuation =+ full_context_continuation(active_continuation.as_ref());continue;}Err(e) => {@@ -443,6 +448,7 @@ impl CodexHttpClient {&failure.message,);transport_failures += 1;+ active_continuation = full_context_continuation(active_continuation.as_ref());sleep(delay.wait_ms).await;continue;}@@ -569,12 +575,13 @@ impl CodexHttpClient {return Err(codex_status_error(response, transport));}Ok(response) => return Ok(response),- Err(err) if should_retry_without_continuation(&err, active_continuation) => {- clear_continuation(ctx.session_id.as_deref());+ Err(err)+ if should_retry_without_continuation(&err, active_continuation.as_ref()) =>+ {if let Some(key) = pool_key {- super::websocket::invalidate_codex_websocket_pool_key(key);+ super::websocket::invalidate_codex_websocket_pool_turn(key, turn_id);}- active_continuation = None;+ active_continuation = full_context_continuation(active_continuation.as_ref());continue;}Err(err) => {@@ -628,11 +635,12 @@ impl CodexHttpClient {origin: CodexErrorOrigin::Auth,})?;+ let turn_id = continuation.and_then(|candidate| candidate.turn_id);let pool_key = websocket_pool_key(ctx, continuation).map(str::to_string);if should_reset_websocket_pool(continuation)&& let Some(key) = pool_key.as_deref(){- super::websocket::invalidate_codex_websocket_pool_key(key);+ super::websocket::invalidate_codex_websocket_pool_turn(key, turn_id);}let client = self.clone();@@ -658,6 +666,9 @@ impl CodexHttpClient {pool_key: Option<String>,tx: tokio::sync::mpsc::Sender<Result<serde_json::Value, CodexError>>,) {+ let turn_id = continuation+ .as_ref()+ .and_then(|candidate| candidate.turn_id);let mut auth_refresh_attempted = false;let mut continuation_retry_available = continuation.as_ref()@@ -688,8 +699,9 @@ impl CodexHttpClient {);let mut stream = tokio::select! {_ = tx.closed() => {+ super::continuation::abort_continuation(ctx.session_id.as_deref(), turn_id);if let Some(key) = pool_key.as_deref() {- super::websocket::invalidate_codex_websocket_pool_key(key);+ super::websocket::invalidate_codex_websocket_pool_turn(key, turn_id);}return;}@@ -698,7 +710,7 @@ impl CodexHttpClient {Err(err) if err.status == 401 && !auth_refresh_attempted && !forwarded_any => {auth_refresh_attempted = true;if let Some(key) = pool_key.as_deref() {- super::websocket::invalidate_codex_websocket_pool_key(key);+ super::websocket::invalidate_codex_websocket_pool_turn(key, turn_id);}let refresh = self.auth_manager.force_refresh(&auth.access);auth = match refresh.await {@@ -713,15 +725,15 @@ impl CodexHttpClient {return;}};+ continuation = full_context_continuation(continuation.as_ref());continue 'attempt;}Err(err) if continuation_retry_available && is_continuation_retry_error(&err) => {continuation_retry_available = false;- super::continuation::clear_continuation(ctx.session_id.as_deref());if let Some(key) = pool_key.as_deref() {- super::websocket::invalidate_codex_websocket_pool_key(key);+ super::websocket::invalidate_codex_websocket_pool_turn(key, turn_id);}- continuation = None;+ continuation = full_context_continuation(continuation.as_ref());continue 'attempt;}Err(err) => {@@ -735,7 +747,7 @@ impl CodexHttpClient {let item = tokio::select! {_ = tx.closed() => {if let Some(key) = pool_key.as_deref() {- super::websocket::invalidate_codex_websocket_pool_key(key);+ super::websocket::invalidate_codex_websocket_pool_turn(key, turn_id);}return;}@@ -752,7 +764,7 @@ impl CodexHttpClient {if unauthorized && !auth_refresh_attempted && !forwarded_any {auth_refresh_attempted = true;if let Some(key) = pool_key.as_deref() {- super::websocket::invalidate_codex_websocket_pool_key(key);+ super::websocket::invalidate_codex_websocket_pool_turn(key, turn_id);}let refresh = self.auth_manager.force_refresh(&auth.access);auth = match refresh.await {@@ -776,18 +788,20 @@ impl CodexHttpClient {&& !forwarded_any{continuation_retry_available = false;- super::continuation::clear_continuation(ctx.session_id.as_deref());if let Some(key) = pool_key.as_deref() {- super::websocket::invalidate_codex_websocket_pool_key(key);+ super::websocket::invalidate_codex_websocket_pool_turn(key, turn_id);}- continuation = None;+ continuation = full_context_continuation(continuation.as_ref());continue 'attempt;}- forwarded_any = true;+ if item.as_ref().is_ok_and(event_closes_live_retry_window) {+ forwarded_any = true;+ }if tx.send(item).await.is_err() {+ super::continuation::abort_continuation(ctx.session_id.as_deref(), turn_id);if let Some(key) = pool_key.as_deref() {- super::websocket::invalidate_codex_websocket_pool_key(key);+ super::websocket::invalidate_codex_websocket_pool_turn(key, turn_id);}return;}@@ -1217,6 +1231,25 @@ fn should_retry_without_continuation(is_continuation_retry_error(err)}+fn full_context_continuation(+ continuation: Option<&super::continuation::ContinuationCandidate>,+) -> Option<super::continuation::ContinuationCandidate> {+ continuation.map(|candidate| super::continuation::ContinuationCandidate {+ turn_id: candidate.turn_id,+ previous_response_id: None,+ input_delta: None,+ input_delta_count: candidate.input_delta_count,+ disabled_reason: Some("full_context_retry".to_string()),+ })+}++fn event_closes_live_retry_window(payload: &serde_json::Value) -> bool {+ !matches!(+ payload.get("type").and_then(|value| value.as_str()),+ Some("codex.rate_limits" | "keepalive")+ )+}+fn is_continuation_retry_error(err: &CodexError) -> bool {matches!(err.detail.as_deref(),@@ -1244,7 +1277,7 @@ fn should_reset_websocket_pool(let Some(reason) = continuation.and_then(|c| c.disabled_reason.as_deref()) else {return false;};- !matches!(reason, "missing_state" | "disabled")+ reason != "disabled"}#[cfg(test)]@@ -1775,18 +1808,21 @@ mod tests {monitor: None,};let disabled = super::super::continuation::ContinuationCandidate {+ turn_id: None,previous_response_id: None,input_delta: None,input_delta_count: 1,disabled_reason: Some("disabled".into()),};let first_enabled = super::super::continuation::ContinuationCandidate {+ turn_id: None,previous_response_id: None,input_delta: None,input_delta_count: 1,disabled_reason: Some("missing_state".into()),};let append = super::super::continuation::ContinuationCandidate {+ turn_id: None,previous_response_id: Some("resp_1".into()),input_delta: None,input_delta_count: 1,@@ -1802,27 +1838,30 @@ mod tests {}#[test]- fn websocket_pool_reset_ignores_initial_and_disabled_states() {+ fn websocket_pool_reset_clears_initial_stale_state() {let missing_state = super::super::continuation::ContinuationCandidate {+ turn_id: None,previous_response_id: None,input_delta: None,input_delta_count: 1,disabled_reason: Some("missing_state".into()),};let disabled = super::super::continuation::ContinuationCandidate {+ turn_id: None,previous_response_id: None,input_delta: None,input_delta_count: 1,disabled_reason: Some("disabled".into()),};let prompt_changed = super::super::continuation::ContinuationCandidate {+ turn_id: None,previous_response_id: None,input_delta: None,input_delta_count: 1,disabled_reason: Some("prompt_changed".into()),};- assert!(!should_reset_websocket_pool(Some(&missing_state)));+ assert!(should_reset_websocket_pool(Some(&missing_state)));assert!(!should_reset_websocket_pool(Some(&disabled)));assert!(should_reset_websocket_pool(Some(&prompt_changed)));}@@ -1932,15 +1971,31 @@ mod tests {assert!(should_fallback_to_http(rejected_handshake_err));}+ #[test]+ fn informational_events_keep_live_continuation_retry_available() {+ assert!(!event_closes_live_retry_window(&serde_json::json!({+ "type": "codex.rate_limits",+ "rate_limits": {"limit_reached": false}+ })));+ assert!(!event_closes_live_retry_window(&serde_json::json!({+ "type": "keepalive"+ })));+ assert!(event_closes_live_retry_window(&serde_json::json!({+ "type": "response.created"+ })));+ }+#[test]fn continuation_retry_requires_previous_response_id() {let append = super::super::continuation::ContinuationCandidate {+ turn_id: None,previous_response_id: Some("resp_1".into()),input_delta: None,input_delta_count: 1,disabled_reason: None,};let initial = super::super::continuation::ContinuationCandidate {+ turn_id: None,previous_response_id: None,input_delta: None,input_delta_count: 1,diff --git a/src/providers/codex/continuation.rs b/src/providers/codex/continuation.rsindex 23ea139..99faa76 100644--- a/src/providers/codex/continuation.rs+++ b/src/providers/codex/continuation.rs@@ -1,5 +1,6 @@use std::collections::HashMap;use std::sync::Mutex;+use std::sync::atomic::{AtomicU64, Ordering};use super::translate::request::{ResponsesInputItem, ResponsesRequest};@@ -17,11 +18,24 @@ struct ContinuationState {updated_at: u64,}-static STATES: Mutex<Option<HashMap<String, ContinuationState>>> = Mutex::new(None);-static TOTAL_TRANSCRIPT_BYTES: Mutex<u64> = Mutex::new(0);+struct SessionState {+ current_turn: u64,+ continuation: Option<ContinuationState>,+ updated_at: u64,+}++#[derive(Default)]+struct ContinuationRegistry {+ sessions: HashMap<String, SessionState>,+ total_transcript_bytes: u64,+}++static REGISTRY: Mutex<Option<ContinuationRegistry>> = Mutex::new(None);+static NEXT_TURN_ID: AtomicU64 = AtomicU64::new(1);#[derive(Clone)]pub struct ContinuationCandidate {+ pub turn_id: Option<u64>,pub previous_response_id: Option<String>,pub input_delta: Option<Vec<ResponsesInputItem>>,pub input_delta_count: usize,@@ -40,10 +54,9 @@ pub fn continuation_candidate(body: &ResponsesRequest,enabled: bool,) -> ContinuationCandidate {- let now = now_ms();-if !enabled {return ContinuationCandidate {+ turn_id: None,previous_response_id: None,input_delta: None,input_delta_count: body.input.len(),@@ -51,47 +64,72 @@ pub fn continuation_candidate(};}- let session_id = match session_id {- Some(s) => s,- None => {- return ContinuationCandidate {- previous_response_id: None,- input_delta: None,- input_delta_count: body.input.len(),- disabled_reason: Some("missing_session".to_string()),- };- }+ let Some(session_id) = session_id else {+ return ContinuationCandidate {+ turn_id: None,+ previous_response_id: None,+ input_delta: None,+ input_delta_count: body.input.len(),+ disabled_reason: Some("missing_session".to_string()),+ };};- let state = {- let guard = STATES.lock().unwrap();- guard.as_ref().and_then(|m| m.get(session_id).cloned())+ let turn_id = NEXT_TURN_ID.fetch_add(1, Ordering::Relaxed);+ let now = now_ms();+ let (state, superseded_turn) = {+ let mut guard = REGISTRY.lock().unwrap();+ let registry = guard.get_or_insert_with(ContinuationRegistry::default);+ let existing = registry.sessions.remove(session_id);+ let superseded_turn = existing.is_some();+ let state = existing.and_then(|session| session.continuation);+ if let Some(state) = &state {+ registry.total_transcript_bytes = registry+ .total_transcript_bytes+ .saturating_sub(state.transcript_bytes);+ }+ registry.sessions.insert(+ session_id.to_string(),+ SessionState {+ current_turn: turn_id,+ continuation: None,+ updated_at: now,+ },+ );+ evict_oldest(registry);+ (state, superseded_turn)};++ continuation_candidate_from_state(turn_id, body, state, superseded_turn, now)+}++fn continuation_candidate_from_state(+ turn_id: u64,+ body: &ResponsesRequest,+ state: Option<ContinuationState>,+ superseded_turn: bool,+ now: u64,+) -> ContinuationCandidate {let state = match state {- Some(s) if now - s.updated_at <= TTL_MS => s,- Some(_) => {- clear_continuation(Some(session_id));+ Some(state) if now.saturating_sub(state.updated_at) <= TTL_MS => state,+ Some(_) | None => {return ContinuationCandidate {+ turn_id: Some(turn_id),previous_response_id: None,input_delta: None,input_delta_count: body.input.len(),- disabled_reason: Some("missing_state".to_string()),- };- }- None => {- return ContinuationCandidate {- previous_response_id: None,- input_delta: None,- input_delta_count: body.input.len(),- disabled_reason: Some("missing_state".to_string()),+ disabled_reason: Some(if superseded_turn {+ "superseded_turn".to_string()+ } else {+ "missing_state".to_string()+ }),};}};let signature = prompt_signature(body);if signature != state.prompt_signature {- clear_continuation(Some(session_id));return ContinuationCandidate {+ turn_id: Some(turn_id),previous_response_id: None,input_delta: None,input_delta_count: body.input.len(),@@ -99,22 +137,19 @@ pub fn continuation_candidate(};}- let suffix = input_suffix_after_prefix(&body.input, &state.transcript);- let suffix = match suffix {- Some(s) => s,- None => {- clear_continuation(Some(session_id));- return ContinuationCandidate {- previous_response_id: None,- input_delta: None,- input_delta_count: body.input.len(),- disabled_reason: Some("not_append_only".to_string()),- };- }+ let Some(suffix) = input_suffix_after_prefix(&body.input, &state.transcript) else {+ return ContinuationCandidate {+ turn_id: Some(turn_id),+ previous_response_id: None,+ input_delta: None,+ input_delta_count: body.input.len(),+ disabled_reason: Some("not_append_only".to_string()),+ };};if suffix.is_empty() {return ContinuationCandidate {+ turn_id: Some(turn_id),previous_response_id: None,input_delta: None,input_delta_count: 0,@@ -123,28 +158,30 @@ pub fn continuation_candidate(}ContinuationCandidate {+ turn_id: Some(turn_id),previous_response_id: Some(state.response_id),- input_delta: Some(suffix.clone()),input_delta_count: suffix.len(),+ input_delta: Some(suffix),disabled_reason: None,}}pub fn record_continuation(session_id: Option<&str>,+ turn_id: Option<u64>,request_body: &ResponsesRequest,response_id: Option<&str>,output_items: &[ResponsesInputItem],) {- let session_id = match session_id {- Some(s) => s,- None => return,+ let (session_id, turn_id) = match (session_id, turn_id) {+ (Some(session_id), Some(turn_id)) => (session_id, turn_id),+ _ => return,};let response_id = match response_id {Some(id) => id.to_string(),None => {- clear_continuation(Some(session_id));+ abort_continuation(Some(session_id), Some(turn_id));return;}};@@ -156,12 +193,10 @@ pub fn record_continuation(let transcript_bytes = transcript_json.len() as u64;if transcript_bytes > MAX_SESSION_TRANSCRIPT_BYTES {- clear_continuation(Some(session_id));+ abort_continuation(Some(session_id), Some(turn_id));return;}- clear_continuation(Some(session_id));-let state = ContinuationState {response_id,prompt_signature: prompt_signature(request_body),@@ -170,42 +205,109 @@ pub fn record_continuation(updated_at: now_ms(),};- {- let mut guard = TOTAL_TRANSCRIPT_BYTES.lock().unwrap();- *guard += transcript_bytes;+ let mut guard = REGISTRY.lock().unwrap();+ let Some(registry) = guard.as_mut() else {+ return;+ };+ let Some(session) = registry.sessions.get_mut(session_id) else {+ return;+ };+ if session.current_turn != turn_id {+ return;+ }+ if let Some(existing) = session.continuation.replace(state) {+ registry.total_transcript_bytes = registry+ .total_transcript_bytes+ .saturating_sub(existing.transcript_bytes);}+ registry.total_transcript_bytes += transcript_bytes;+ evict_oldest(registry);+}++pub fn abort_continuation(session_id: Option<&str>, turn_id: Option<u64>) {+ let (Some(session_id), Some(turn_id)) = (session_id, turn_id) else {+ return;+ };+ let mut guard = REGISTRY.lock().unwrap();+ let Some(registry) = guard.as_mut() else {+ return;+ };+ if registry+ .sessions+ .get(session_id)+ .is_some_and(|session| session.current_turn == turn_id)+ && let Some(session) = registry.sessions.remove(session_id)+ && let Some(state) = session.continuation{- let mut guard = STATES.lock().unwrap();- let map = guard.get_or_insert_with(HashMap::new);- map.insert(session_id.to_string(), state);+ registry.total_transcript_bytes = registry+ .total_transcript_bytes+ .saturating_sub(state.transcript_bytes);}- evict_oldest();+}++pub fn if_current_turn<T>(+ session_id: Option<&str>,+ turn_id: Option<u64>,+ action: impl FnOnce() -> T,+) -> Option<T> {+ let (Some(session_id), Some(turn_id)) = (session_id, turn_id) else {+ return Some(action());+ };+ let guard = REGISTRY.lock().unwrap();+ let current = guard+ .as_ref()+ .and_then(|registry| registry.sessions.get(session_id))+ .is_some_and(|session| session.current_turn == turn_id);+ current.then(action)+}++pub fn with_current_turn(+ session_id: Option<&str>,+ turn_id: Option<u64>,+ action: impl FnOnce(),+) -> bool {+ if_current_turn(session_id, turn_id, action).is_some()+}++pub fn is_current_turn(session_id: Option<&str>, turn_id: Option<u64>) -> bool {+ let (Some(session_id), Some(turn_id)) = (session_id, turn_id) else {+ return false;+ };+ let guard = REGISTRY.lock().unwrap();+ guard+ .as_ref()+ .and_then(|registry| registry.sessions.get(session_id))+ .is_some_and(|session| session.current_turn == turn_id)}pub fn clear_continuation(session_id: Option<&str>) {- let session_id = match session_id {- Some(s) => s,- None => return,+ let Some(session_id) = session_id else {+ return;};- let mut guard = STATES.lock().unwrap();- if let Some(map) = guard.as_mut()- && let Some(existing) = map.remove(session_id)+ let mut guard = REGISTRY.lock().unwrap();+ let Some(registry) = guard.as_mut() else {+ return;+ };+ if let Some(session) = registry.sessions.remove(session_id)+ && let Some(state) = session.continuation{- let mut bytes_guard = TOTAL_TRANSCRIPT_BYTES.lock().unwrap();- *bytes_guard = bytes_guard.saturating_sub(existing.transcript_bytes);+ registry.total_transcript_bytes = registry+ .total_transcript_bytes+ .saturating_sub(state.transcript_bytes);}}pub fn has_continuation_for_tests(session_id: &str) -> bool {- let guard = STATES.lock().unwrap();- guard.as_ref().is_some_and(|m| m.contains_key(session_id))+ let guard = REGISTRY.lock().unwrap();+ guard+ .as_ref()+ .and_then(|registry| registry.sessions.get(session_id))+ .is_some_and(|session| session.continuation.is_some())}pub fn clear_all_continuations_for_tests() {- let mut guard = STATES.lock().unwrap();+ let mut guard = REGISTRY.lock().unwrap();*guard = None;- let mut bytes_guard = TOTAL_TRANSCRIPT_BYTES.lock().unwrap();- *bytes_guard = 0;}fn input_suffix_after_prefix(@@ -273,22 +375,24 @@ fn stable_json(value: &serde_json::Value) -> String {}}-fn evict_oldest() {- let mut guard = STATES.lock().unwrap();- let map = match guard.as_mut() {- Some(m) => m,- None => return,- };- let mut bytes_guard = TOTAL_TRANSCRIPT_BYTES.lock().unwrap();- while map.len() > MAX_STATES || *bytes_guard > MAX_TOTAL_TRANSCRIPT_BYTES {- let key = map.keys().next().cloned();- match key {- Some(k) => {- if let Some(existing) = map.remove(&k) {- *bytes_guard = bytes_guard.saturating_sub(existing.transcript_bytes);- }- }- None => break,+fn evict_oldest(registry: &mut ContinuationRegistry) {+ while registry.sessions.len() > MAX_STATES+ || registry.total_transcript_bytes > MAX_TOTAL_TRANSCRIPT_BYTES+ {+ let key = registry+ .sessions+ .iter()+ .min_by_key(|(_, session)| session.updated_at)+ .map(|(key, _)| key.clone());+ let Some(key) = key else {+ break;+ };+ if let Some(session) = registry.sessions.remove(&key)+ && let Some(state) = session.continuation+ {+ registry.total_transcript_bytes = registry+ .total_transcript_bytes+ .saturating_sub(state.transcript_bytes);}}}@@ -319,6 +423,17 @@ mod tests {serde_json::from_value(serde_json::Value::Object(fields)).unwrap()}+ fn start_and_record(session_id: &str, request: &ResponsesRequest, response_id: Option<&str>) {+ let candidate = continuation_candidate(Some(session_id), request, true);+ record_continuation(+ Some(session_id),+ candidate.turn_id,+ request,+ response_id,+ &[],+ );+ }+#[test]fn continuation_behaviors() {// All tests run in sequence to avoid global state interference@@ -363,7 +478,7 @@ mod tests {],}];let req = request_with_input(input, None);- record_continuation(Some("s1"), &req, Some("resp_1"), &[]);+ start_and_record("s1", &req, Some("resp_1"));let input2 = vec![ResponsesInputItem::Message {@@ -399,7 +514,7 @@ mod tests {],}];let req = request_with_input(input.clone(), None);- record_continuation(Some("s1"), &req, Some("resp_1"), &[]);+ start_and_record("s1", &req, Some("resp_1"));let req2 = request_with_input(input, Some(json!({"service_tier": "flex"})));let result = continuation_candidate(Some("s1"), &req2, true);@@ -417,10 +532,26 @@ mod tests {],}];let req = request_with_input(input.clone(), None);- record_continuation(Some("s1"), &req, Some("resp_1"), &[]);+ start_and_record("s1", &req, Some("resp_1"));assert!(has_continuation_for_tests("s1"));- record_continuation(Some("s1"), &req, None, &[]);+ let candidate = continuation_candidate(Some("s1"), &req, true);+ record_continuation(Some("s1"), candidate.turn_id, &req, None, &[]);+ assert!(!has_continuation_for_tests("s1"));++ // stale turns cannot publish or clear a newer turn+ clear_all_continuations_for_tests();+ let first = continuation_candidate(Some("s1"), &req, true);+ record_continuation(Some("s1"), first.turn_id, &req, Some("resp_1"), &[]);+ let second = continuation_candidate(Some("s1"), &req, true);+ let third = continuation_candidate(Some("s1"), &req, true);+ assert_eq!(third.disabled_reason.as_deref(), Some("superseded_turn"));++ record_continuation(Some("s1"), second.turn_id, &req, Some("resp_2"), &[]);assert!(!has_continuation_for_tests("s1"));+ record_continuation(Some("s1"), third.turn_id, &req, Some("resp_3"), &[]);+ assert!(has_continuation_for_tests("s1"));+ abort_continuation(Some("s1"), second.turn_id);+ assert!(has_continuation_for_tests("s1"));}}diff --git a/src/providers/codex/mod.rs b/src/providers/codex/mod.rsindex f93aa3c..4aa192a 100644--- a/src/providers/codex/mod.rs+++ b/src/providers/codex/mod.rs@@ -29,7 +29,7 @@ use self::auth::manager::CodexAuthManager;use self::auth::token_store::file_store;use self::client::CodexHttpClient;use self::continuation::{- ContinuationCandidate, clear_continuation, continuation_candidate, record_continuation,+ ContinuationCandidate, abort_continuation, continuation_candidate, record_continuation,};use self::count_tokens::count_translated_tokens;use self::translate::accumulate::accumulate_response_with_traffic;@@ -135,6 +135,7 @@ impl Provider for CodexProvider {&translated,previous_response_id_enabled,);+ let turn_id = continuation.turn_id;// Post to upstream with continuationlet client = self.client.clone();@@ -160,7 +161,7 @@ impl Provider for CodexProvider {{Ok(r) => r,Err(e) => {- clear_continuation(ctx.session_id.as_deref());+ abort_continuation(ctx.session_id.as_deref(), turn_id);return map_codex_error_to_response(&e);}};@@ -174,7 +175,7 @@ impl Provider for CodexProvider {) {Ok(b) => b,Err(e) => {- clear_continuation(ctx.session_id.as_deref());+ abort_continuation(ctx.session_id.as_deref(), turn_id);return map_codex_failure_to_response(&format!("Stream translation error: {e}"));@@ -192,6 +193,7 @@ impl Provider for CodexProvider {}update_continuation_from_upstream(ctx.session_id.as_deref(),+ turn_id,&translated,&upstream.body,);@@ -220,13 +222,14 @@ impl Provider for CodexProvider {}update_continuation_from_upstream(ctx.session_id.as_deref(),+ turn_id,&translated,&upstream.body,);(StatusCode::OK, Json(json)).into_response()}Err(e) => {- clear_continuation(ctx.session_id.as_deref());+ abort_continuation(ctx.session_id.as_deref(), turn_id);map_codex_failure_to_response(&format!("Accumulation error: {e}"))}}@@ -302,10 +305,7 @@ fn count_sse_events(bytes: &[u8]) -> u64 {enum LiveStreamStart {Response(Response),- Retry {- error: client::CodexError,- full_context: bool,- },+ Retry { error: client::CodexError },}async fn live_stream_response(@@ -317,6 +317,7 @@ async fn live_stream_response(continuation: ContinuationCandidate,) -> Response {let model = model.to_string();+ let turn_id = continuation.turn_id;let mut attempt = 0_u32;let mut continuation = Some(continuation);@@ -327,19 +328,18 @@ async fn live_stream_response({Ok(events) => events,Err(err) if retryable_live_start_codex_error(&err) => {- if retry_with_full_context_for_live_error(&err)- && drop_live_continuation_for_retry(&mut continuation, &ctx)- {+ let dropped = drop_live_continuation_for_retry(&mut continuation);+ if dropped && is_missing_previous_response_error(&err) {attempt += 1;continue;}if attempt >= MAX_RETRYABLE_LIVE_STREAM_RETRIES {- clear_continuation(ctx.session_id.as_deref());+ abort_continuation(ctx.session_id.as_deref(), turn_id);return map_codex_error_to_response(&err);}let delay = compute_backoff_delay(attempt, err.retry_after.as_deref());if delay.exceeds_budget {- clear_continuation(ctx.session_id.as_deref());+ abort_continuation(ctx.session_id.as_deref(), turn_id);return map_codex_error_to_response(&err);}attempt += 1;@@ -347,7 +347,7 @@ async fn live_stream_response(continue;}Err(err) => {- clear_continuation(ctx.session_id.as_deref());+ abort_continuation(ctx.session_id.as_deref(), turn_id);return map_codex_error_to_response(&err);}};@@ -357,26 +357,25 @@ async fn live_stream_response(message_id.clone(),&model,ctx.clone(),+ turn_id,request_body.clone(),).await{LiveStreamStart::Response(response) => return response,- LiveStreamStart::Retry {- error,- full_context,- } => {- if full_context && drop_live_continuation_for_retry(&mut continuation, &ctx) {+ LiveStreamStart::Retry { error } => {+ let dropped = drop_live_continuation_for_retry(&mut continuation);+ if dropped && is_missing_previous_response_error(&error) {attempt += 1;continue;}if attempt >= MAX_RETRYABLE_LIVE_STREAM_RETRIES {- clear_continuation(ctx.session_id.as_deref());+ abort_continuation(ctx.session_id.as_deref(), turn_id);return map_codex_error_to_response(&error);}let delay = compute_backoff_delay(attempt, error.retry_after.as_deref());if delay.exceeds_budget {- clear_continuation(ctx.session_id.as_deref());+ abort_continuation(ctx.session_id.as_deref(), turn_id);return map_codex_error_to_response(&error);}attempt += 1;@@ -391,6 +390,7 @@ async fn live_stream_response_once(message_id: String,model: &str,ctx: RequestContext,+ turn_id: Option<u64>,request_body: translate::request::ResponsesRequest,) -> LiveStreamStart {let mut translator = LiveStreamTranslator::new(message_id, model.to_string());@@ -401,13 +401,9 @@ async fn live_stream_response_once(Ok(payload) => payload,Err(err) => {if retryable_live_start_codex_error(&err) {- let full_context = retry_with_full_context_for_live_error(&err);- return LiveStreamStart::Retry {- error: err,- full_context,- };+ return LiveStreamStart::Retry { error: err };}- clear_continuation(ctx.session_id.as_deref());+ abort_continuation(ctx.session_id.as_deref(), turn_id);return LiveStreamStart::Response(map_codex_error_to_response(&err));}};@@ -447,10 +443,9 @@ async fn live_stream_response_once(retry_after: retry_after_from_live_payload(&payload),origin: client::CodexErrorOrigin::WebSocket,},- full_context: false,};}- clear_continuation(ctx.session_id.as_deref());+ abort_continuation(ctx.session_id.as_deref(), turn_id);return LiveStreamStart::Response(map_codex_failure_to_response(&message));}};@@ -459,6 +454,7 @@ async fn live_stream_response_once(if terminal {update_continuation_from_upstream(ctx.session_id.as_deref(),+ turn_id,&request_body,&upstream_sse_body,);@@ -469,6 +465,7 @@ async fn live_stream_response_once(translator,chunk,ctx,+ turn_id,request_body,upstream_sse_body,));@@ -476,6 +473,7 @@ async fn live_stream_response_once(if terminal {update_continuation_from_upstream(ctx.session_id.as_deref(),+ turn_id,&request_body,&upstream_sse_body,);@@ -491,7 +489,6 @@ async fn live_stream_response_once(retry_after: None,origin: client::CodexErrorOrigin::WebSocket,},- full_context: true,}}@@ -533,13 +530,14 @@ fn remaining_live_stream_response(mut translator: LiveStreamTranslator,first_chunk: Vec<u8>,ctx: RequestContext,+ turn_id: Option<u64>,request_body: translate::request::ResponsesRequest,mut upstream_sse_body: Vec<u8>,) -> Response {let (tx, rx) = tokio::sync::mpsc::channel::<Result<Bytes, std::io::Error>>(64);tokio::spawn(async move {if tx.send(Ok(Bytes::from(first_chunk))).await.is_err() {- clear_continuation(ctx.session_id.as_deref());+ abort_continuation(ctx.session_id.as_deref(), turn_id);return;}while let Some(item) = upstream_events.recv().await {@@ -550,7 +548,7 @@ fn remaining_live_stream_response(match translate_live_stream_payload(&mut translator, &payload, &ctx) {Ok(result) => result,Err(message) => {- clear_continuation(ctx.session_id.as_deref());+ abort_continuation(ctx.session_id.as_deref(), turn_id);let chunk = translator.error_chunk(&message,"api_error",@@ -566,13 +564,14 @@ fn remaining_live_stream_response(if !chunk.is_empty() {record_live_stream_progress(&ctx, &chunk);if tx.send(Ok(Bytes::from(chunk))).await.is_err() {- clear_continuation(ctx.session_id.as_deref());+ abort_continuation(ctx.session_id.as_deref(), turn_id);return;}}if terminal {update_continuation_from_upstream(ctx.session_id.as_deref(),+ turn_id,&request_body,&upstream_sse_body,);@@ -580,7 +579,7 @@ fn remaining_live_stream_response(}}Err(err) => {- clear_continuation(ctx.session_id.as_deref());+ abort_continuation(ctx.session_id.as_deref(), turn_id);let chunk =translator.finish_after_closed_completed_tool_call(ctx.traffic.as_deref());if !chunk.is_empty() {@@ -603,7 +602,7 @@ fn remaining_live_stream_response(}}- clear_continuation(ctx.session_id.as_deref());+ abort_continuation(ctx.session_id.as_deref(), turn_id);let chunk = translator.finish_after_closed_completed_tool_call(ctx.traffic.as_deref());if !chunk.is_empty() {record_live_stream_progress(&ctx, &chunk);@@ -669,19 +668,11 @@ fn retryable_live_start_codex_error(err: &client::CodexError) -> bool {|| (err.status == 0 && retryable_live_message(codex_error_message(err)))}-fn retry_with_full_context_for_live_error(err: &client::CodexError) -> bool {- matches!(- err.detail.as_deref(),- Some("previous_response_not_found")- | Some(websocket::WEBSOCKET_RESPONSE_START_TIMEOUT_DETAIL)- | Some(websocket::WEBSOCKET_MISSING_TERMINAL_DETAIL)- )+fn is_missing_previous_response_error(err: &client::CodexError) -> bool {+ err.detail.as_deref() == Some("previous_response_not_found")}-fn drop_live_continuation_for_retry(- continuation: &mut Option<ContinuationCandidate>,- ctx: &RequestContext,-) -> bool {+fn drop_live_continuation_for_retry(continuation: &mut Option<ContinuationCandidate>) -> bool {if continuation.as_ref().and_then(|candidate| candidate.previous_response_id.as_deref())@@ -690,8 +681,11 @@ fn drop_live_continuation_for_retry(return false;}- clear_continuation(ctx.session_id.as_deref());- *continuation = None;+ if let Some(candidate) = continuation.as_mut() {+ candidate.previous_response_id = None;+ candidate.input_delta = None;+ candidate.disabled_reason = Some("full_context_retry".to_string());+ }true}@@ -734,6 +728,7 @@ fn codex_stream_error_type(err: &client::CodexError) -> &'static str {fn update_continuation_from_upstream(session_id: Option<&str>,+ turn_id: Option<u64>,request_body: &translate::request::ResponsesRequest,upstream_body: &[u8],) {@@ -741,12 +736,13 @@ fn update_continuation_from_upstream(Ok(Some(finish)) if finish.continuation_eligible => {record_continuation(session_id,+ turn_id,request_body,finish.response_id.as_deref(),&finish.output_items,);}- _ => clear_continuation(session_id),+ _ => abort_continuation(session_id, turn_id),}}diff --git a/src/providers/codex/websocket.rs b/src/providers/codex/websocket.rsindex cf89dcd..b31ae33 100644--- a/src/providers/codex/websocket.rs+++ b/src/providers/codex/websocket.rs@@ -111,6 +111,45 @@ pub fn invalidate_codex_websocket_pool_key(session_id: &str) {guard.remove(session_id);}+pub fn invalidate_codex_websocket_pool_turn(session_id: &str, turn_id: Option<u64>) {+ super::continuation::with_current_turn(Some(session_id), turn_id, || {+ invalidate_codex_websocket_pool_key(session_id)+ });+}++fn invalidate_pool_entry(session_id: &str, entry: &Arc<PoolEntry>) {+ let mut guard = WS_POOL.lock().unwrap();+ if guard+ .get(session_id)+ .is_some_and(|pooled| Arc::ptr_eq(pooled, entry))+ {+ guard.remove(session_id);+ }+}++fn invalidate_pool_owner(pool_key: Option<&str>, entry: Option<&Arc<PoolEntry>>) {+ let Some(session_id) = pool_key else {+ return;+ };+ match entry {+ Some(entry) => invalidate_pool_entry(session_id, entry),+ None => invalidate_codex_websocket_pool_key(session_id),+ }+}++fn pool_get_for_turn(key: &str, turn_id: Option<u64>) -> Option<Arc<PoolEntry>> {+ super::continuation::if_current_turn(Some(key), turn_id, || {+ let guard = WS_POOL.lock().ok()?;+ guard.get(key).cloned()+ })+ .flatten()+}++fn pool_insert_for_turn(key: String, entry: Arc<PoolEntry>, turn_id: Option<u64>) {+ let session_id = key.clone();+ super::continuation::with_current_turn(Some(&session_id), turn_id, || pool_insert(key, entry));+}+fn pool_insert(key: String, entry: Arc<PoolEntry>) {let mut guard = WS_POOL.lock().unwrap();// Evict oldest if at capacity@@ -296,8 +335,7 @@ pub async fn codex_websocket_request(// Check pool for existing connectionlet pooled = pool_key.and_then(|key| {- let guard = WS_POOL.lock().ok()?;- guard.get(key).cloned()+ pool_get_for_turn(key, continuation.and_then(|candidate| candidate.turn_id))});let (ws_stream, _response) = if let Some(entry) = pooled {@@ -305,7 +343,7 @@ pub async fn codex_websocket_request(let mut ws_guard = entry.ws.lock().await;// Check if connection is still alive by sending a pingif ws_guard.send(Message::Ping(vec![])).await.is_err() {- invalidate_codex_websocket_pool_key(pool_key.unwrap());+ invalidate_pool_entry(pool_key.unwrap(), &entry);// Fall through to new connectionconnect_with_timeout(&ws_url, headers, connect_timeout_ms).await?} else {@@ -313,7 +351,7 @@ pub async fn codex_websocket_request(let ws_msg = Message::Text(body_json.clone());ws_guard.send(ws_msg).await.map_err(|e| {if let Some(key) = pool_key {- invalidate_codex_websocket_pool_key(key);+ invalidate_pool_entry(key, &entry);}CodexError {status: 0,@@ -325,8 +363,14 @@ pub async fn codex_websocket_request(})?;// Collect events- let (sse_body, terminal_event) =- collect_ws_events(&mut ws_guard, idle_timeout_ms, pool_key, traffic).await?;+ let (sse_body, terminal_event) = collect_ws_events(+ &mut ws_guard,+ idle_timeout_ms,+ pool_key,+ Some(&entry),+ traffic,+ )+ .await?;let Some(terminal_event) = terminal_event else {return Err(missing_terminal_error());};@@ -383,15 +427,21 @@ pub async fn codex_websocket_request(origin: CodexErrorOrigin::WebSocket,})?;- let (sse_body, terminal_event) =- collect_ws_events(&mut ws_guard, idle_timeout_ms, pool_key, traffic).await?;+ let (sse_body, terminal_event) = collect_ws_events(+ &mut ws_guard,+ idle_timeout_ms,+ pool_key,+ Some(&entry),+ traffic,+ )+ .await?;let Some(terminal_event) = terminal_event else {return Err(missing_terminal_error());};if is_previous_response_missing(&terminal_event.payload) {if let Some(key) = pool_key {- invalidate_codex_websocket_pool_key(key);+ invalidate_pool_entry(key, &entry);}return Err(CodexError {status: 0,@@ -406,7 +456,11 @@ pub async fn codex_websocket_request(if let Some(key) = pool_key {let should_pool = terminal_event.event_type == "response.completed";if should_pool {- pool_insert(key.to_string(), entry.clone());+ pool_insert_for_turn(+ key.to_string(),+ entry.clone(),+ continuation.and_then(|candidate| candidate.turn_id),+ );}}@@ -475,8 +529,7 @@ pub async fn codex_websocket_event_stream(}let pooled = pool_key.and_then(|key| {- let guard = WS_POOL.lock().ok()?;- guard.get(key).cloned()+ pool_get_for_turn(key, continuation.and_then(|candidate| candidate.turn_id))});let used_pooled = pooled.is_some();let entry = if let Some(entry) = pooled {@@ -494,13 +547,14 @@ pub async fn codex_websocket_event_stream(}let (tx, rx) = mpsc::channel(64);+ let turn_id = continuation.and_then(|candidate| candidate.turn_id);let pool_key = pool_key.map(str::to_string);let ws = entry.ws.clone();tokio::spawn(async move {let mut ws_guard = ws.lock_owned().await;if used_pooled && ws_guard.send(Message::Ping(vec![])).await.is_err() {if let Some(key) = pool_key.as_deref() {- invalidate_codex_websocket_pool_key(key);+ invalidate_pool_entry(key, &entry);}let _ = tx.send(Err(CodexError {@@ -515,7 +569,7 @@ pub async fn codex_websocket_event_stream(}if let Err(e) = ws_guard.send(Message::Text(body_json)).await {if let Some(key) = pool_key.as_deref() {- invalidate_codex_websocket_pool_key(key);+ invalidate_pool_entry(key, &entry);}let _ = tx.send(Err(CodexError {@@ -533,6 +587,7 @@ pub async fn codex_websocket_event_stream(&mut ws_guard,idle_timeout_ms,pool_key.as_deref(),+ Some(&entry),traffic,tx,)@@ -541,10 +596,10 @@ pub async fn codex_websocket_event_stream(if let Some(key) = pool_key.as_deref() {if reusable {if !used_pooled {- pool_insert(key.to_string(), entry.clone());+ pool_insert_for_turn(key.to_string(), entry.clone(), turn_id);}} else {- invalidate_codex_websocket_pool_key(key);+ invalidate_pool_entry(key, &entry);}}});@@ -732,6 +787,7 @@ async fn collect_ws_events(ws: &mut WebSocketStream<MaybeTlsStream<TcpStream>>,idle_timeout_ms: u64,pool_key: Option<&str>,+ pool_entry: Option<&Arc<PoolEntry>>,traffic: Option<&TrafficCapture>,) -> Result<(Vec<u8>, Option<WsEvent>), CodexError> {let mut sse_body: Vec<u8> = Vec::new();@@ -751,9 +807,7 @@ async fn collect_ws_events(match response_event_budget.checked_sub(response_deadline_started.elapsed()) {Some(remaining) if !remaining.is_zero() => remaining,_ => {- if let Some(key) = pool_key {- invalidate_codex_websocket_pool_key(key);- }+ invalidate_pool_owner(pool_key, pool_entry);return Err(CodexError {status: 0,message: format!("WebSocket idle timeout after {idle_timeout_ms}ms"),@@ -767,9 +821,7 @@ async fn collect_ws_events(match response_event_budget.checked_sub(response_deadline_started.elapsed()) {Some(remaining) if !remaining.is_zero() => remaining,_ => {- if let Some(key) = pool_key {- invalidate_codex_websocket_pool_key(key);- }+ invalidate_pool_owner(pool_key, pool_entry);return Err(response_start_timeout_error(idle_timeout_ms));}}@@ -778,9 +830,7 @@ async fn collect_ws_events(let timeout = tokio::time::timeout(read_timeout, ws.next());let frame = timeout.await.map_err(|_| {- if let Some(key) = pool_key {- invalidate_codex_websocket_pool_key(key);- }+ invalidate_pool_owner(pool_key, pool_entry);if response_started {CodexError {status: 0,@@ -841,9 +891,7 @@ async fn collect_ws_events(}Some(Ok(Message::Binary(_))) => {// Reject binary frames- if let Some(key) = pool_key {- invalidate_codex_websocket_pool_key(key);- }+ invalidate_pool_owner(pool_key, pool_entry);return Err(CodexError {status: 0,message: "WebSocket binary frames not supported".to_string(),@@ -866,16 +914,12 @@ async fn collect_ws_events(}Some(Ok(Message::Close(_))) => {// Connection closed - invalidate pool- if let Some(key) = pool_key {- invalidate_codex_websocket_pool_key(key);- }+ invalidate_pool_owner(pool_key, pool_entry);break;}Some(Err(e)) => {// Stream error - invalidate pool- if let Some(key) = pool_key {- invalidate_codex_websocket_pool_key(key);- }+ invalidate_pool_owner(pool_key, pool_entry);return Err(CodexError {status: 0,message: format!("WebSocket stream error: {e}"),@@ -886,9 +930,7 @@ async fn collect_ws_events(}None => {// Stream ended - invalidate pool- if let Some(key) = pool_key {- invalidate_codex_websocket_pool_key(key);- }+ invalidate_pool_owner(pool_key, pool_entry);break;}}@@ -901,6 +943,7 @@ async fn stream_ws_events(ws: &mut WebSocketStream<MaybeTlsStream<TcpStream>>,idle_timeout_ms: u64,pool_key: Option<&str>,+ pool_entry: Option<&Arc<PoolEntry>>,traffic: Option<Arc<TrafficCapture>>,tx: mpsc::Sender<Result<serde_json::Value, CodexError>>,) -> bool {@@ -923,9 +966,7 @@ async fn stream_ws_events(match response_event_budget.checked_sub(response_deadline_started.elapsed()) {Some(remaining) if !remaining.is_zero() => remaining,_ => {- if let Some(key) = pool_key {- invalidate_codex_websocket_pool_key(key);- }+ invalidate_pool_owner(pool_key, pool_entry);let err = if response_started {CodexError {status: 0,@@ -945,9 +986,7 @@ async fn stream_ws_events(let frame = match tokio::time::timeout(read_timeout, ws.next()).await {Ok(frame) => frame,Err(_) => {- if let Some(key) = pool_key {- invalidate_codex_websocket_pool_key(key);- }+ invalidate_pool_owner(pool_key, pool_entry);let err = if response_started {CodexError {status: 0,@@ -998,9 +1037,7 @@ async fn stream_ws_events(}let terminal = is_terminal_event(&parsed);if terminal && is_previous_response_missing(&parsed) {- if let Some(key) = pool_key {- invalidate_codex_websocket_pool_key(key);- }+ invalidate_pool_owner(pool_key, pool_entry);let _ = tx.send(Err(CodexError {status: 0,@@ -1018,9 +1055,7 @@ async fn stream_ws_events(.unwrap_or("unknown").to_string();if tx.send(Ok(parsed)).await.is_err() {- if let Some(key) = pool_key {- invalidate_codex_websocket_pool_key(key);- }+ invalidate_pool_owner(pool_key, pool_entry);break;}if terminal {@@ -1029,9 +1064,7 @@ async fn stream_ws_events(}}Some(Ok(Message::Binary(_))) => {- if let Some(key) = pool_key {- invalidate_codex_websocket_pool_key(key);- }+ invalidate_pool_owner(pool_key, pool_entry);let _ = tx.send(Err(CodexError {status: 0,@@ -1048,16 +1081,12 @@ async fn stream_ws_events(}Some(Ok(Message::Pong(_))) | Some(Ok(Message::Frame(_))) => {}Some(Ok(Message::Close(_))) | None => {- if let Some(key) = pool_key {- invalidate_codex_websocket_pool_key(key);- }+ invalidate_pool_owner(pool_key, pool_entry);let _ = tx.send(Err(missing_terminal_error())).await;break;}Some(Err(e)) => {- if let Some(key) = pool_key {- invalidate_codex_websocket_pool_key(key);- }+ invalidate_pool_owner(pool_key, pool_entry);let _ = tx.send(Err(CodexError {status: 0,@@ -1368,7 +1397,8 @@ mod tests {let (mut ws, _) = tokio_tungstenite::connect_async(format!("ws://{addr}/")).await.unwrap();- let err = match collect_ws_events(&mut ws, 1_000, Some("binary-session"), None).await {+ let err = match collect_ws_events(&mut ws, 1_000, Some("binary-session"), None, None).await+ {Ok(_) => panic!("expected binary frame to fail"),Err(err) => err,};@@ -1413,10 +1443,11 @@ mod tests {let (mut ws, _) = tokio_tungstenite::connect_async(format!("ws://{addr}/")).await.unwrap();- let err = match collect_ws_events(&mut ws, 50, Some("start-timeout-session"), None).await {- Ok(_) => panic!("expected response start timeout"),- Err(err) => err,- };+ let err =+ match collect_ws_events(&mut ws, 50, Some("start-timeout-session"), None, None).await {+ Ok(_) => panic!("expected response start timeout"),+ Err(err) => err,+ };assert_eq!(err.detail.as_deref(),@@ -1467,10 +1498,11 @@ mod tests {let (mut ws, _) = tokio_tungstenite::connect_async(format!("ws://{addr}/")).await.unwrap();- let err = match collect_ws_events(&mut ws, 50, Some("response-idle-session"), None).await {- Ok(_) => panic!("expected response idle timeout"),- Err(err) => err,- };+ let err =+ match collect_ws_events(&mut ws, 50, Some("response-idle-session"), None, None).await {+ Ok(_) => panic!("expected response idle timeout"),+ Err(err) => err,+ };assert!(err.message.contains("idle timeout"));assert_eq!(err.detail, None);diff --git a/tests/smoke_cutover.rs b/tests/smoke_cutover.rsindex aef8a1e..afb5927 100644--- a/tests/smoke_cutover.rs+++ b/tests/smoke_cutover.rs@@ -379,6 +379,11 @@ async fn spawn_websocket_previous_missing_then_retry_upstream(}if handled == 1 {+ let rate_limits = json!({+ "type": "codex.rate_limits",+ "rate_limits": {"limit_reached": false}+ });+ let _ = sender.send(Message::Text(rate_limits.to_string())).await;let event = json!({"type": "error","error": {