Skip to content

Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy

Rust

use idle timeout for Codex HTTP response bodies

Raine Virta524e3413d527
diff --git a/src/providers/codex/client.rs b/src/providers/codex/client.rs
index a1e2748..91d12cb 100644
--- a/src/providers/codex/client.rs
+++ b/src/providers/codex/client.rs
@@ -201,11 +201,14 @@ pub struct CodexResponse {
// Client
// ---------------------------------------------------------------------------
+const HTTP_RESPONSE_BODY_IDLE_TIMEOUT_MS: u64 = 300_000;
+
pub struct CodexHttpClient {
client: reqwest::Client,
auth_manager: CodexAuthManager<DefaultCodexAuthStore>,
base_url: String,
header_timeout_ms: u64,
+ body_idle_timeout_ms: u64,
#[allow(dead_code)]
header_timeout_retries: u32,
}
@@ -222,12 +225,12 @@ impl CodexHttpClient {
Self {
client: reqwest::Client::builder()
.connect_timeout(Duration::from_secs(15))
- .timeout(Duration::from_millis(timeout_ms + 10_000))
.build()
.expect("failed to create HTTP client"),
auth_manager: CodexAuthManager::new(file_store()),
base_url: config::codex_base_url(CODEX_API_ENDPOINT),
header_timeout_ms: timeout_ms,
+ body_idle_timeout_ms: HTTP_RESPONSE_BODY_IDLE_TIMEOUT_MS,
header_timeout_retries: 1,
}
}
@@ -242,6 +245,7 @@ impl CodexHttpClient {
auth_manager,
base_url,
header_timeout_ms: 60_000,
+ body_idle_timeout_ms: HTTP_RESPONSE_BODY_IDLE_TIMEOUT_MS,
header_timeout_retries: 1,
}
}
@@ -251,6 +255,7 @@ impl CodexHttpClient {
client: reqwest::Client,
base_url: String,
header_timeout_ms: u64,
+ body_idle_timeout_ms: u64,
header_timeout_retries: u32,
) -> Self {
Self {
@@ -258,6 +263,7 @@ impl CodexHttpClient {
auth_manager: CodexAuthManager::new(file_store()),
base_url,
header_timeout_ms,
+ body_idle_timeout_ms,
header_timeout_retries,
}
}
@@ -624,7 +630,7 @@ impl CodexHttpClient {
let send_fut = req_builder.body(body_json.to_string()).send();
let header_timeout_dur = Duration::from_millis(self.header_timeout_ms);
- let resp = tokio::time::timeout(header_timeout_dur, send_fut)
+ let mut resp = tokio::time::timeout(header_timeout_dur, send_fut)
.await
.map_err(|_| CodexError {
status: 0,
@@ -663,7 +669,36 @@ impl CodexHttpClient {
.map(|(k, v)| (k.to_string(), v.to_str().unwrap_or("").to_string()))
.collect();
- let body_bytes = resp.bytes().await.unwrap_or_default().to_vec();
+ let mut body_bytes = Vec::new();
+ loop {
+ let chunk = tokio::time::timeout(
+ Duration::from_millis(self.body_idle_timeout_ms),
+ resp.chunk(),
+ )
+ .await
+ .map_err(|_| CodexError {
+ status: 0,
+ message: format!(
+ "Timed out waiting {}ms for the next Codex response body chunk",
+ self.body_idle_timeout_ms
+ ),
+ detail: Some("http_response_body".to_string()),
+ retry_after: None,
+ origin: CodexErrorOrigin::Http,
+ })?
+ .map_err(|e| CodexError {
+ status: 0,
+ message: format!("Transport error reading Codex response body: {e}"),
+ detail: Some("http_response_body".to_string()),
+ retry_after: None,
+ origin: CodexErrorOrigin::Http,
+ })?;
+
+ let Some(chunk) = chunk else {
+ break;
+ };
+ body_bytes.extend_from_slice(&chunk);
+ }
if let Some(traffic) = ctx.traffic.as_deref() {
write_upstream_response_capture(
@@ -891,6 +926,123 @@ fn should_reset_websocket_pool(
#[cfg(test)]
mod tests {
use super::*;
+ use tokio::io::{AsyncReadExt, AsyncWriteExt};
+ use tokio::net::TcpListener;
+
+ fn http_test_auth() -> StoredAuth {
+ StoredAuth {
+ access: "test".into(),
+ refresh: String::new(),
+ account_id: Some("acct".into()),
+ expires: u64::MAX,
+ }
+ }
+
+ fn http_test_context() -> RequestContext {
+ RequestContext {
+ req_id: "http-body-test".into(),
+ session_id: None,
+ session_seq: None,
+ provider: "codex".into(),
+ traffic: None,
+ monitor: None,
+ }
+ }
+
+ fn http_test_client(base_url: String, body_idle_timeout_ms: u64) -> CodexHttpClient {
+ CodexHttpClient::new_for_test(
+ reqwest::Client::new(),
+ base_url,
+ 100,
+ body_idle_timeout_ms,
+ 0,
+ )
+ }
+
+ #[tokio::test]
+ async fn active_http_body_can_exceed_header_timeout() {
+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+ let addr = listener.local_addr().unwrap();
+ let server = tokio::spawn(async move {
+ let (mut stream, _) = listener.accept().await.unwrap();
+ let mut request = [0_u8; 4096];
+ assert!(stream.read(&mut request).await.unwrap() > 0);
+ stream
+ .write_all(
+ b"HTTP/1.1 200 OK\r\ntransfer-encoding: chunked\r\nconnection: close\r\n\r\n",
+ )
+ .await
+ .unwrap();
+ for chunk in [b"a".as_slice(), b"b", b"c"] {
+ stream.write_all(b"1\r\n").await.unwrap();
+ stream.write_all(chunk).await.unwrap();
+ stream.write_all(b"\r\n").await.unwrap();
+ tokio::time::sleep(Duration::from_millis(45)).await;
+ }
+ stream.write_all(b"0\r\n\r\n").await.unwrap();
+ });
+
+ let response = http_test_client(format!("http://{addr}/responses"), 80)
+ .attempt_post_http(&http_test_auth(), "{}", &http_test_context(), false)
+ .await
+ .expect("active body should not hit a whole-request timeout");
+ server.await.unwrap();
+
+ assert_eq!(response.body, b"abc");
+ }
+
+ #[tokio::test]
+ async fn stalled_http_body_hits_idle_timeout() {
+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+ let addr = listener.local_addr().unwrap();
+ let server = tokio::spawn(async move {
+ let (mut stream, _) = listener.accept().await.unwrap();
+ let mut request = [0_u8; 4096];
+ assert!(stream.read(&mut request).await.unwrap() > 0);
+ stream
+ .write_all(b"HTTP/1.1 200 OK\r\ncontent-length: 1\r\n\r\n")
+ .await
+ .unwrap();
+ tokio::time::sleep(Duration::from_millis(100)).await;
+ });
+
+ let result = http_test_client(format!("http://{addr}/responses"), 30)
+ .attempt_post_http(&http_test_auth(), "{}", &http_test_context(), false)
+ .await;
+ server.await.unwrap();
+ let error = result.err().expect("stalled body should time out");
+
+ assert!(error.message.contains("next Codex response body chunk"));
+ assert_eq!(error.detail.as_deref(), Some("http_response_body"));
+ }
+
+ #[tokio::test]
+ async fn reset_http_body_returns_transport_error() {
+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+ let addr = listener.local_addr().unwrap();
+ let server = tokio::spawn(async move {
+ let (mut stream, _) = listener.accept().await.unwrap();
+ let mut request = [0_u8; 4096];
+ assert!(stream.read(&mut request).await.unwrap() > 0);
+ stream
+ .write_all(b"HTTP/1.1 200 OK\r\ncontent-length: 10\r\n\r\npartial")
+ .await
+ .unwrap();
+ });
+
+ let result = http_test_client(format!("http://{addr}/responses"), 100)
+ .attempt_post_http(&http_test_auth(), "{}", &http_test_context(), false)
+ .await;
+ server.await.unwrap();
+ let error = result.err().expect("truncated body should fail");
+
+ assert!(
+ error
+ .message
+ .contains("Transport error reading Codex response body")
+ );
+ assert_eq!(error.detail.as_deref(), Some("http_response_body"));
+ }
#[test]
fn codex_error_display() {