Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy
Rust
codex: fix websocket continuation pooling
Raine Virtaab80dff044cf
diff --git a/src/config.rs b/src/config.rsindex 45ffffd..f06df4e 100644--- a/src/config.rs+++ b/src/config.rs@@ -431,8 +431,10 @@ fn parse_codex_transport(raw: &str) -> Option<CodexTransport> {pub fn codex_transport() -> CodexTransport {let env: HashMap<_, _> = std::env::vars().collect();- if let Some(raw) = env.get("CCP_CODEX_TRANSPORT") {- return parse_codex_transport(raw).unwrap_or(CodexTransport::Http);+ if let Some(raw) = env.get("CCP_CODEX_TRANSPORT")+ && let Some(transport) = parse_codex_transport(raw)+ {+ return transport;}let config_dir = paths::config_dir();if let Some(file) = read_file_config(&config_dir)@@ -441,7 +443,7 @@ pub fn codex_transport() -> CodexTransport {{return transport;}- CodexTransport::Http+ CodexTransport::WebSocket}// ---------------------------------------------------------------------------@@ -508,11 +510,11 @@ mod tests {}#[test]- fn codex_transport_defaults_to_http() {+ fn codex_transport_defaults_to_websocket() {let _guard = ENV_LOCK.lock().unwrap();clear_env();let result = codex_transport();- assert_eq!(result, CodexTransport::Http);+ assert_eq!(result, CodexTransport::WebSocket);}#[test]@@ -536,13 +538,23 @@ mod tests {}#[test]- fn codex_transport_invalid_env_falls_back_to_http() {+ fn codex_transport_invalid_env_falls_back_to_websocket() {let _guard = ENV_LOCK.lock().unwrap();clear_env();unsafe {std::env::set_var("CCP_CODEX_TRANSPORT", "invalid");}- assert_eq!(codex_transport(), CodexTransport::Http);+ assert_eq!(codex_transport(), CodexTransport::WebSocket);+ }++ #[test]+ fn codex_transport_empty_env_falls_back_to_websocket() {+ let _guard = ENV_LOCK.lock().unwrap();+ clear_env();+ unsafe {+ std::env::set_var("CCP_CODEX_TRANSPORT", "");+ }+ assert_eq!(codex_transport(), CodexTransport::WebSocket);}#[test]diff --git a/src/providers/codex/client.rs b/src/providers/codex/client.rsindex 19049f3..c9de29c 100644--- a/src/providers/codex/client.rs+++ b/src/providers/codex/client.rs@@ -275,6 +275,12 @@ impl CodexHttpClient {})?;let transport = crate::config::codex_transport();+ let pool_key = websocket_pool_key(ctx, continuation);+ if should_reset_websocket_pool(continuation)+ && let Some(key) = pool_key+ {+ super::websocket::invalidate_codex_websocket_pool_key(key);+ }for transport_attempt in 0..=3u32 {let result = match transport {@@ -293,11 +299,6 @@ impl CodexHttpClient {let ws_headers = super::websocket::codex_websocket_headers(&ws_headers);let ws_body = build_websocket_request(body, continuation);- let pool_key = ctx.session_id.as_deref();- let pool_key = continuation- .and_then(|c| c.previous_response_id.as_ref())- .and(pool_key);-super::websocket::codex_websocket_request(&self.base_url,&ws_headers,@@ -316,11 +317,6 @@ impl CodexHttpClient {let ws_headers = super::websocket::codex_websocket_headers(&ws_headers);let ws_body = build_websocket_request(body, continuation);- let pool_key = ctx.session_id.as_deref();- let pool_key = continuation- .and_then(|c| c.previous_response_id.as_ref())- .and(pool_key);-// Try WebSocket firstlet ws_result = super::websocket::codex_websocket_request(&self.base_url,@@ -411,9 +407,9 @@ impl CodexHttpClient {Err(err) if err.detail.as_deref() == Some("previous_response_not_found") => {// Previous response missing: clear continuation and retry once with full requestclear_continuation(ctx.session_id.as_deref());- super::websocket::invalidate_codex_websocket_pool_key(- ctx.session_id.as_deref().unwrap_or(""),- );+ if let Some(key) = pool_key {+ super::websocket::invalidate_codex_websocket_pool_key(key);+ }// Retry with the full body (no continuation) through the relevant transportlet retry_headers = build_codex_headers(&auth, ctx)?;@@ -426,10 +422,10 @@ impl CodexHttpClient {})?;match transport {- CodexTransport::Http | CodexTransport::Auto => {+ CodexTransport::Http => {return self.attempt_post_http(&auth, &full_body_json, ctx).await;}- CodexTransport::WebSocket => {+ CodexTransport::WebSocket | CodexTransport::Auto => {let ws_retry_headers =super::websocket::codex_websocket_headers(&retry_headers);let ws_retry_body = build_websocket_request(body, None);@@ -439,7 +435,7 @@ impl CodexHttpClient {&ws_retry_body,ctx,ctx.traffic.as_deref(),- None,+ pool_key,super::websocket::WEBSOCKET_CONNECT_TIMEOUT_MS,super::websocket::WEBSOCKET_IDLE_TIMEOUT_MS,None,@@ -694,6 +690,27 @@ fn is_retryable_reqwest_error(err: &reqwest::Error) -> bool {|| msg.contains("epipe")}+fn websocket_pool_key<'a>(+ ctx: &'a RequestContext,+ continuation: Option<&super::continuation::ContinuationCandidate>,+) -> Option<&'a str> {+ let session_id = ctx.session_id.as_deref()?;+ let continuation = continuation?;+ if continuation.disabled_reason.as_deref() == Some("disabled") {+ return None;+ }+ Some(session_id)+}++fn should_reset_websocket_pool(+ continuation: Option<&super::continuation::ContinuationCandidate>,+) -> bool {+ let Some(reason) = continuation.and_then(|c| c.disabled_reason.as_deref()) else {+ return false;+ };+ !matches!(reason, "missing_state" | "disabled")+}+#[cfg(test)]mod tests {use super::*;@@ -794,6 +811,68 @@ mod tests {assert!(payload.get("previous_response_id").is_none());}+ #[test]+ fn websocket_pool_key_tracks_continuation_opt_in() {+ let ctx = RequestContext {+ req_id: "r".into(),+ session_id: Some("session".into()),+ session_seq: None,+ provider: "codex".into(),+ traffic: None,+ };+ let disabled = super::super::continuation::ContinuationCandidate {+ previous_response_id: None,+ input_delta: None,+ input_delta_count: 1,+ disabled_reason: Some("disabled".into()),+ };+ let first_enabled = super::super::continuation::ContinuationCandidate {+ previous_response_id: None,+ input_delta: None,+ input_delta_count: 1,+ disabled_reason: Some("missing_state".into()),+ };+ let append = super::super::continuation::ContinuationCandidate {+ previous_response_id: Some("resp_1".into()),+ input_delta: None,+ input_delta_count: 1,+ disabled_reason: None,+ };++ assert_eq!(websocket_pool_key(&ctx, Some(&disabled)), None);+ assert_eq!(+ websocket_pool_key(&ctx, Some(&first_enabled)),+ Some("session")+ );+ assert_eq!(websocket_pool_key(&ctx, Some(&append)), Some("session"));+ }++ #[test]+ fn websocket_pool_reset_ignores_initial_and_disabled_states() {+ let missing_state = super::super::continuation::ContinuationCandidate {+ previous_response_id: None,+ input_delta: None,+ input_delta_count: 1,+ disabled_reason: Some("missing_state".into()),+ };+ let disabled = super::super::continuation::ContinuationCandidate {+ previous_response_id: None,+ input_delta: None,+ input_delta_count: 1,+ disabled_reason: Some("disabled".into()),+ };+ let prompt_changed = super::super::continuation::ContinuationCandidate {+ 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(&disabled)));+ assert!(should_reset_websocket_pool(Some(&prompt_changed)));+ }+#[test]fn build_codex_headers_error_on_empty_access() {let auth = StoredAuth {diff --git a/src/providers/codex/websocket.rs b/src/providers/codex/websocket.rsindex 88dbdd1..12d3324 100644--- a/src/providers/codex/websocket.rs+++ b/src/providers/codex/websocket.rs@@ -315,16 +315,6 @@ pub async fn codex_websocket_request(let (sse_body, terminal_event) =collect_ws_events(&mut ws_guard, idle_timeout_ms, pool_key, traffic).await?;- // Record continuation on success- if let Some(terminal) = &terminal_event- && terminal.payload.get("response").is_some()- {- // Record continuation for successful responses- if let Some(key) = pool_key {- invalidate_codex_websocket_pool_key(key);- }- }-// Handle previous response missingif let Some(terminal) = &terminal_event&& is_previous_response_missing(&terminal.payload)diff --git a/tests/smoke_cutover.rs b/tests/smoke_cutover.rsindex 0870a8e..511de47 100644--- a/tests/smoke_cutover.rs+++ b/tests/smoke_cutover.rs@@ -216,7 +216,9 @@ async fn spawn_websocket_sequence_upstream(captured: Arc<Mutex<Vec<Value>>>) ->let addr_str = format!("http://{addr}");tokio::spawn(async move {- for (idx, text) in ["first", "second"].iter().enumerate() {+ let texts = ["first", "second", "third"];+ let mut handled = 0usize;+ while handled < texts.len() {let Ok((stream, _)) = listener.accept().await else {return;};@@ -225,37 +227,53 @@ async fn spawn_websocket_sequence_upstream(captured: Arc<Mutex<Vec<Value>>>) ->};let (mut sender, mut receiver) = ws.split();- if let Some(Ok(Message::Text(text))) = receiver.next().await- && let Ok(json) = serde_json::from_str::<Value>(&text)- {- let _ = captured.lock().map(|mut g| g.push(json));- }-- let response_id = format!("resp_{}", idx + 1);- let events = [- json!({- "type":"response.output_item.added",- "output_index":0,- "item":{"type":"message","id":format!("msg_up_{idx}")}- }),- json!({- "type":"response.output_text.delta",- "output_index":0,- "delta":text- }),- json!({- "type":"response.output_item.done",- "output_index":0,- "item":{"type":"message"}- }),- json!({- "type":"response.completed",- "response":{"id":response_id,"usage":{"input_tokens":5,"output_tokens":2}}- }),- ];-- for event in &events {- let _ = sender.send(Message::Text(event.to_string())).await;+ while handled < texts.len() {+ let Some(text) = (loop {+ match receiver.next().await {+ Some(Ok(Message::Text(text))) => break Some(text),+ Some(Ok(Message::Ping(data))) => {+ let _ = sender.send(Message::Pong(data)).await;+ }+ Some(Ok(Message::Pong(_))) => {}+ Some(Ok(_)) => {}+ Some(Err(_)) | None => break None,+ }+ }) else {+ break;+ };+ if let Ok(json) = serde_json::from_str::<Value>(&text) {+ let _ = captured.lock().map(|mut g| g.push(json));+ }++ let idx = handled;+ let response_text = texts[idx];+ let response_id = format!("resp_{}", idx + 1);+ let events = [+ json!({+ "type":"response.output_item.added",+ "output_index":0,+ "item":{"type":"message","id":format!("msg_up_{idx}")}+ }),+ json!({+ "type":"response.output_text.delta",+ "output_index":0,+ "delta":response_text+ }),+ json!({+ "type":"response.output_item.done",+ "output_index":0,+ "item":{"type":"message"}+ }),+ json!({+ "type":"response.completed",+ "response":{"id":response_id,"usage":{"input_tokens":5,"output_tokens":2}}+ }),+ ];++ for event in &events {+ let _ = sender.send(Message::Text(event.to_string())).await;+ }+ handled += 1;}}});@@ -546,17 +564,46 @@ async fn smoke_codex_websocket_previous_response_id_sends_delta_on_second_turn()]})).await;- assert_eq!(second.status(), StatusCode::OK);- let value: Value = serde_json::from_slice(- &axum::body::to_bytes(second.into_body(), usize::MAX)- .await- .unwrap(),- )- .unwrap();+ let second_status = second.status();+ let second_body = axum::body::to_bytes(second.into_body(), usize::MAX)+ .await+ .unwrap();+ assert_eq!(+ second_status,+ StatusCode::OK,+ "second response body: {}",+ String::from_utf8_lossy(&second_body)+ );+ let value: Value = serde_json::from_slice(&second_body).unwrap();assert_eq!(value["content"][0]["text"], "second");+ let third = call_messages_body(json!({+ "model": "gpt-5.5",+ "max_tokens": 64,+ "messages": [+ {"role":"user","content":"one"},+ {"role":"assistant","content":"first"},+ {"role":"user","content":"two"},+ {"role":"assistant","content":"second"},+ {"role":"user","content":"three"}+ ]+ }))+ .await;+ let third_status = third.status();+ let third_body = axum::body::to_bytes(third.into_body(), usize::MAX)+ .await+ .unwrap();+ assert_eq!(+ third_status,+ StatusCode::OK,+ "third response body: {}",+ String::from_utf8_lossy(&third_body)+ );+ let value: Value = serde_json::from_slice(&third_body).unwrap();+ assert_eq!(value["content"][0]["text"], "third");+let guard = captured.lock().unwrap();- assert_eq!(guard.len(), 2, "expected two upstream websocket requests");+ assert_eq!(guard.len(), 3, "expected three upstream websocket requests");assert!(guard[0].get("previous_response_id").is_none());assert_eq!(guard[1]["previous_response_id"], "resp_1");assert_eq!(@@ -566,6 +613,14 @@ async fn smoke_codex_websocket_previous_response_id_sends_delta_on_second_turn());assert_eq!(guard[1]["input"][0]["role"], "user");assert_eq!(guard[1]["input"][0]["content"][0]["text"], "two");+ assert_eq!(guard[2]["previous_response_id"], "resp_2");+ assert_eq!(+ guard[2]["input"].as_array().map(Vec::len),+ Some(1),+ "third request should keep reusing the pooled websocket continuation"+ );+ assert_eq!(guard[2]["input"][0]["role"], "user");+ assert_eq!(guard[2]["input"][0]["content"][0]["text"], "three");clear_all_continuations_for_tests();clear_codex_websocket_pool_for_tests();