feat(codex): implement body size limit and logging for Codex responses

Author: Yoo1tic

src/server/router.rs

@@ -8,7 +8,7 @@ use crate::server::routes::{codex, geminicli};
 
 use axum::{
     Router,
-    extract::{DefaultBodyLimit, FromRef, Request},
+    extract::{FromRef, Request},
     http::{HeaderName, StatusCode, Version, header::USER_AGENT},
     middleware::{self, Next},
     response::Response,
@@ -226,7 +226,5 @@ pub fn pollux_router(state: PolluxState) -> Router {
         .merge(codex)
         .fallback(not_found_handler)
         .with_state(state)
-        // Set DefaultBodyLimit to 30 MiB for all routes
-        .layer(DefaultBodyLimit::max(30 * 1024 * 1024))
         .layer(middleware::from_fn(access_log))
 }

src/server/routes/codex/mod.rs

@@ -1,8 +1,13 @@
 use crate::server::router::PolluxState;
 use axum::{
     Router,
+    extract::{DefaultBodyLimit, Request},
+    http::header::CONTENT_LENGTH,
+    middleware::{self, Next},
+    response::Response,
     routing::{get, post},
 };
+use tracing::debug;
 
 pub mod extract;
 pub mod handlers;
@@ -14,6 +19,8 @@ use crate::providers::codex::SUPPORTED_MODEL_NAMES;
 use pollux_schema::openai::OpenaiModelList;
 use std::sync::LazyLock;
 
+const CODEX_RESPONSES_BODY_LIMIT_BYTES: usize = 100 * 1024 * 1024;
+
 pub static CODEX_MODEL_LIST: LazyLock<OpenaiModelList> = LazyLock::new(|| {
     OpenaiModelList::from_model_names(SUPPORTED_MODEL_NAMES.iter().cloned(), "codex".to_string())
 });
@@ -25,11 +32,36 @@ pub struct CodexContext {
     pub model_mask: u64,
 }
 
+async fn debug_codex_responses_body_size(req: Request, next: Next) -> Response {
+    let content_length = req
+        .headers()
+        .get(CONTENT_LENGTH)
+        .and_then(|value| value.to_str().ok())
+        .and_then(|value| value.parse::<u64>().ok());
+
+    match content_length {
+        Some(bytes) => {
+            debug!(
+                content_length_bytes = bytes,
+                content_length_mib = format_args!("{:.2}", bytes as f64 / (1024.0 * 1024.0)),
+                "Incoming Codex /responses request body size"
+            );
+        }
+        None => {
+            debug!("Incoming Codex /responses request body size unknown (no Content-Length)");
+        }
+    }
+
+    next.run(req).await
+}
+
 pub fn router() -> Router<PolluxState> {
     Router::new()
         .route(
             "/codex/v1/responses",
-            post(handlers::codex_response_handler),
+            post(handlers::codex_response_handler)
+                .layer(DefaultBodyLimit::max(CODEX_RESPONSES_BODY_LIMIT_BYTES))
+                .layer(middleware::from_fn(debug_codex_responses_body_size)),
         )
         .route("/codex/v1/models", get(handlers::codex_models_handler))
         .route("/codex/resource:add", post(resource::codex_resource_add))

tests/codex_route_basic_tests.rs

@@ -119,7 +119,7 @@ async fn codex_response_route_rejects_bad_requests_and_requires_key() {
         r#"{"error":{"code":"NO_CREDENTIAL","message":"No available credentials to process the request.","type":"NO_CREDENTIAL"}}"#
     );
 
-    // 5) correct key + oversized JSON body -> 413
+    // 5) correct key + 30 MiB JSON body -> 503 (Codex endpoint limit is higher than 30 MiB)
     let oversized_input = "a".repeat(30 * 1024 * 1024 + 1024);
     let oversized_payload = format!(r#"{{"model":"{model}","input":"{oversized_input}"}}"#);
     let resp = app
@@ -135,14 +135,16 @@ async fn codex_response_route_rejects_bad_requests_and_requires_key() {
         )
         .await
         .expect("request failed");
-    assert_eq!(resp.status(), StatusCode::PAYLOAD_TOO_LARGE);
+    assert_eq!(resp.status(), StatusCode::SERVICE_UNAVAILABLE);
 
     let body = to_bytes(resp.into_body(), usize::MAX)
         .await
         .expect("failed to read response body");
     let body_str = std::str::from_utf8(&body).expect("response body was not utf-8");
-    assert!(body_str.contains(r#""code":"PAYLOAD_TOO_LARGE""#));
-    assert!(body_str.contains(r#""message":"request body too large""#));
+    assert_eq!(
+        body_str,
+        r#"{"error":{"code":"NO_CREDENTIAL","message":"No available credentials to process the request.","type":"NO_CREDENTIAL"}}"#
+    );
 
     // 6) GET /codex/v1/models: no key -> 401
     let resp = app