Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy
Rust
separate WebSocket preparation from request delivery
Raine Virtaffa371646c98
diff --git a/src/providers/codex/websocket.rs b/src/providers/codex/websocket.rsindex b8672e7..4457c9b 100644--- a/src/providers/codex/websocket.rs+++ b/src/providers/codex/websocket.rs@@ -5,8 +5,8 @@ use std::time::{Duration, Instant};use futures_util::{SinkExt, StreamExt};use http::HeaderMap;use tokio::net::TcpStream;-use tokio::sync::Mutex as AsyncMutex;use tokio::sync::mpsc;+use tokio::sync::{Mutex as AsyncMutex, OwnedMutexGuard};use tokio_tungstenite::{MaybeTlsStream, WebSocketStream, connect_async,tungstenite::{self, Message, handshake::client::generate_key},@@ -486,97 +486,130 @@ pub async fn codex_websocket_request(}}-#[allow(clippy::too_many_arguments)]-pub async fn codex_websocket_event_stream(+pub(super) struct ReadyWebSocket {+ guard: OwnedMutexGuard<WebSocketStream<MaybeTlsStream<TcpStream>>>,+ entry: Arc<PoolEntry>,+ used_pooled: bool,+ pool_key: Option<String>,+ turn_id: Option<u64>,+ traffic: Option<Arc<TrafficCapture>>,+ idle_timeout_ms: u64,+}++pub(super) async fn prepare_codex_websocket(url: &str,headers: &HeaderMap,- body_value: &serde_json::Value,- _ctx: &RequestContext,traffic: Option<Arc<TrafficCapture>>,pool_key: Option<&str>,+ turn_id: Option<u64>,connect_timeout_ms: u64,idle_timeout_ms: u64,- continuation: Option<&ContinuationCandidate>,-) -> Result<CodexWebSocketEventReceiver, CodexError> {- let ws_url = to_websocket_url(url).map_err(|e| CodexError {+) -> Result<ReadyWebSocket, CodexError> {+ let ws_url = to_websocket_url(url).map_err(|error| CodexError {status: 0,- message: e.message,+ message: error.message,detail: None,retry_after: None,- origin: CodexErrorOrigin::WebSocket,+ origin: CodexErrorOrigin::WebSocketHandshake,})?;+ let pooled = pool_key.and_then(|key| pool_get_for_turn(key, turn_id));+ let used_pooled = pooled.is_some();+ let entry = if let Some(entry) = pooled {+ entry+ } else {+ let (stream, _) = connect_with_timeout(&ws_url, headers, connect_timeout_ms).await?;+ Arc::new(PoolEntry {+ ws: Arc::new(AsyncMutex::new(stream)),+ created_at: now_ms(),+ })+ };+ let mut guard = entry.ws.clone().lock_owned().await;+ if used_pooled {+ let nonce = b"codex-ready".to_vec();+ guard+ .send(Message::Ping(nonce.clone()))+ .await+ .map_err(|error| pooled_validation_error(pool_key, error.to_string()))?;+ let validation = tokio::time::timeout(Duration::from_millis(connect_timeout_ms), async {+ loop {+ match guard.next().await {+ Some(Ok(Message::Pong(payload))) if payload == nonce => return Ok(()),+ Some(Ok(Message::Ping(payload))) => guard+ .send(Message::Pong(payload))+ .await+ .map_err(|error| error.to_string())?,+ Some(Ok(_)) => {+ return Err("unexpected frame during pooled validation".to_string());+ }+ Some(Err(error)) => return Err(error.to_string()),+ None => return Err("connection closed during pooled validation".to_string()),+ }+ }+ })+ .await+ .map_err(|_| pooled_validation_error(pool_key, "validation timeout".to_string()))?;+ validation.map_err(|error| pooled_validation_error(pool_key, error))?;+ }+ Ok(ReadyWebSocket {+ guard,+ entry,+ used_pooled,+ pool_key: pool_key.map(str::to_string),+ turn_id,+ traffic,+ idle_timeout_ms,+ })+}++fn pooled_validation_error(pool_key: Option<&str>, detail: String) -> CodexError {+ if let Some(key) = pool_key {+ invalidate_codex_websocket_pool_key(key);+ }+ CodexError {+ status: 0,+ message: format!("WebSocket pooled connection validation failed: {detail}"),+ detail: None,+ retry_after: None,+ origin: CodexErrorOrigin::WebSocketHandshake,+ }+}++pub(super) fn start_codex_websocket_events(+ ready: ReadyWebSocket,+ body_value: &serde_json::Value,+ headers: &HeaderMap,+ _continuation: Option<&ContinuationCandidate>,+) -> CodexWebSocketEventReceiver {let body_json = serde_json::to_string(body_value).unwrap_or_default();- if let Some(tc) = traffic.as_deref() {+ if let Some(tc) = ready.traffic.as_deref() {tc.write_json("020-upstream-request", body_value);tc.write_json("021-upstream-request-metadata",&serde_json::json!({"provider": "codex","transport": "websocket",- "url": ws_url,- "method": "GET","headers": headers_to_json(headers),"size": summarize_json_request_size(body_value, &body_json),- "continuation": {- "previousResponseId": continuation- .and_then(|c| c.previous_response_id.as_deref()),- "inputDeltaCount": continuation- .and_then(|c| c.input_delta.as_ref())- .map(|items| items.len()),- "disabledReason": continuation- .and_then(|c| c.disabled_reason.as_deref()),- },}),);}-- let pooled = pool_key.and_then(|key| {- 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 {- entry- } else {- let (ws_stream, _) = connect_with_timeout(&ws_url, headers, connect_timeout_ms).await?;- Arc::new(PoolEntry {- ws: Arc::new(AsyncMutex::new(ws_stream)),- created_at: now_ms(),- })- };-- if let Some(tc) = traffic.as_deref() {- write_websocket_metadata_capture(tc, &ws_url, pool_key, continuation, used_pooled);- }-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_pool_entry(key, &entry);- }- let _ = tx- .send(Err(CodexError {- status: 0,- message: "WebSocket send error: failed to ping pooled connection".to_string(),- detail: None,- retry_after: None,- origin: CodexErrorOrigin::WebSocket,- }))- .await;- return;- }- if let Err(e) = ws_guard.send(Message::Text(body_json)).await {- if let Some(key) = pool_key.as_deref() {- invalidate_pool_entry(key, &entry);- }+ let ReadyWebSocket {+ mut guard,+ entry,+ used_pooled,+ pool_key,+ turn_id,+ traffic,+ idle_timeout_ms,+ } = ready;+ if let Err(error) = guard.send(Message::Text(body_json)).await {+ invalidate_pool_owner(pool_key.as_deref(), Some(&entry));let _ = tx.send(Err(CodexError {status: 0,- message: format!("WebSocket send error: {e}"),+ message: format!("WebSocket send error: {error}"),detail: None,retry_after: None,origin: CodexErrorOrigin::WebSocket,@@ -584,9 +617,8 @@ pub async fn codex_websocket_event_stream(.await;return;}-let reusable = stream_ws_events(- &mut ws_guard,+ &mut guard,idle_timeout_ms,pool_key.as_deref(),Some(&entry),@@ -594,18 +626,45 @@ pub async fn codex_websocket_event_stream(tx,).await;-if let Some(key) = pool_key.as_deref() {- if reusable {- if !used_pooled {- pool_insert_for_turn(key.to_string(), entry.clone(), turn_id);- }- } else {+ if reusable && !used_pooled {+ pool_insert_for_turn(key.to_string(), entry, turn_id);+ } else if !reusable {invalidate_pool_entry(key, &entry);}}});- Ok(rx)+ rx+}++#[allow(clippy::too_many_arguments)]+pub async fn codex_websocket_event_stream(+ url: &str,+ headers: &HeaderMap,+ body_value: &serde_json::Value,+ _ctx: &RequestContext,+ traffic: Option<Arc<TrafficCapture>>,+ pool_key: Option<&str>,+ connect_timeout_ms: u64,+ idle_timeout_ms: u64,+ continuation: Option<&ContinuationCandidate>,+) -> Result<CodexWebSocketEventReceiver, CodexError> {+ let ready = prepare_codex_websocket(+ url,+ headers,+ traffic,+ pool_key,+ continuation.and_then(|candidate| candidate.turn_id),+ connect_timeout_ms,+ idle_timeout_ms,+ )+ .await?;+ Ok(start_codex_websocket_events(+ ready,+ body_value,+ headers,+ continuation,+ ))}fn missing_terminal_error() -> CodexError {