Skip to content

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.rs
index 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.rs
index 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 first
let 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 request
clear_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 transport
let 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.rs
index 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 missing
if let Some(terminal) = &terminal_event
&& is_previous_response_missing(&terminal.payload)
diff --git a/tests/smoke_cutover.rs b/tests/smoke_cutover.rs
index 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();