Skip to content

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.rs
index 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 first
let 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.rs
index 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.rs
index 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 continuation
let 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.rs
index 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 connection
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 (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 ping
if 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 connection
connect_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.rs
index 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": {