Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy
Rust
stream Codex HTTP responses incrementally (#51)
mulfyx52a739e1c774
diff --git a/src/providers/codex/client.rs b/src/providers/codex/client.rsindex fcbfe33..39ebae9 100644--- a/src/providers/codex/client.rs+++ b/src/providers/codex/client.rs@@ -350,6 +350,135 @@ pub struct CodexResponse {pub transport: ActualTransport,}+pub type CodexHttpEventReceiver =+ tokio::sync::mpsc::Receiver<Result<serde_json::Value, CodexError>>;++const MAX_HTTP_SSE_FRAME_BYTES: usize = 8 * 1024 * 1024;++#[derive(Default)]+struct HttpSseDecoder {+ frame: Vec<u8>,+ line_start: usize,+ skip_lf: bool,+}++struct DecodedHttpSseEvent {+ event: Option<String>,+ payload: Option<serde_json::Value>,+}++struct HttpEventStreamState {+ resp: reqwest::Response,+ started_at: Instant,+ body_json: String,+ auth: StoredAuth,+ auth_refresh_attempted: bool,+ use_responses_lite: bool,+ retries: u32,+}++impl HttpSseDecoder {+ fn push(&mut self, input: &[u8]) -> Result<Vec<DecodedHttpSseEvent>, CodexError> {+ let mut events = Vec::new();+ for &byte in input {+ if self.skip_lf {+ self.skip_lf = false;+ if byte == b'\n' {+ continue;+ }+ }+ match byte {+ b'\n' => self.end_line(&mut events)?,+ b'\r' => {+ self.end_line(&mut events)?;+ self.skip_lf = true;+ }+ _ => self.push_byte(byte)?,+ }+ }+ Ok(events)+ }++ fn finish(&self) -> Result<(), CodexError> {+ if self.frame.is_empty() {+ Ok(())+ } else {+ Err(http_sse_error(+ "Codex SSE stream ended with an incomplete frame",+ ))+ }+ }++ fn push_byte(&mut self, byte: u8) -> Result<(), CodexError> {+ if self.frame.len() >= MAX_HTTP_SSE_FRAME_BYTES {+ return Err(http_sse_error("Codex SSE frame exceeds the size limit"));+ }+ self.frame.push(byte);+ Ok(())+ }++ fn end_line(&mut self, events: &mut Vec<DecodedHttpSseEvent>) -> Result<(), CodexError> {+ if self.frame.len() == self.line_start {+ if !self.frame.is_empty()+ && let Some(event) = decode_http_sse_frame(&self.frame)?+ {+ events.push(event);+ }+ self.frame.clear();+ self.line_start = 0;+ return Ok(());+ }+ self.push_byte(b'\n')?;+ self.line_start = self.frame.len();+ Ok(())+ }+}++fn decode_http_sse_frame(frame: &[u8]) -> Result<Option<DecodedHttpSseEvent>, CodexError> {+ let frame = std::str::from_utf8(frame)+ .map_err(|_| http_sse_error("Codex SSE frame contains invalid UTF-8"))?;+ let mut event = None;+ let mut data = Vec::new();+ for line in frame.lines() {+ if line.starts_with(':') {+ continue;+ }+ let (field, value) = line.split_once(':').unwrap_or((line, ""));+ let value = value.strip_prefix(' ').unwrap_or(value);+ match field {+ "event" => event = Some(value.to_owned()),+ "data" => data.push(value),+ _ => {}+ }+ }+ if data.is_empty() {+ return Ok(None);+ }+ let data = data.join("\n");+ if data == "[DONE]" {+ return Ok(Some(DecodedHttpSseEvent {+ event,+ payload: None,+ }));+ }+ let payload = serde_json::from_str(&data)+ .map_err(|_| http_sse_error("Codex SSE frame contains invalid JSON"))?;+ Ok(Some(DecodedHttpSseEvent {+ event,+ payload: Some(payload),+ }))+}++fn http_sse_error(message: &str) -> CodexError {+ CodexError {+ status: 0,+ message: message.to_string(),+ detail: Some("http_response_sse".to_string()),+ retry_after: None,+ origin: CodexErrorOrigin::Http,+ }+}+// ---------------------------------------------------------------------------// Client// ---------------------------------------------------------------------------@@ -947,6 +1076,436 @@ impl CodexHttpClient {}}+ pub async fn stream_codex_http_events(+ self: &Arc<Self>,+ body: &ResponsesRequest,+ ctx: &RequestContext,+ ) -> Result<CodexHttpEventReceiver, CodexError> {+ let mut auth = self.auth_manager.get_auth().await.map_err(|e| CodexError {+ status: 401,+ message: "Auth error".to_string(),+ detail: Some(e.to_string()),+ retry_after: None,+ origin: CodexErrorOrigin::Auth,+ })?;+ let body_json = serde_json::to_string(body).map_err(|e| CodexError {+ status: 500,+ message: "Failed to serialize request".to_string(),+ detail: Some(e.to_string()),+ retry_after: None,+ origin: CodexErrorOrigin::Http,+ })?;+ let mut auth_refresh_attempted = false;+ let use_responses_lite = body.client_metadata.is_some();+ let mut retries = 0_u32;+ let (resp, started_at) = loop {+ match self+ .start_http_event_attempt(+ &mut auth,+ &body_json,+ ctx,+ use_responses_lite,+ &mut auth_refresh_attempted,+ )+ .await+ {+ Ok(attempt) => break attempt,+ Err(error) if retryable_http_stream_error(&error) => {+ if retries >= MAX_BUFFERED_TRANSPORT_RETRIES {+ return Err(error);+ }+ let delay = compute_backoff_delay(retries, error.retry_after.as_deref());+ if delay.exceeds_budget {+ return Err(error);+ }+ retries += 1;+ sleep(delay.wait_ms).await;+ }+ Err(error) => return Err(error),+ }+ };++ Ok(self.spawn_http_event_stream(+ HttpEventStreamState {+ resp,+ started_at,+ body_json,+ auth,+ auth_refresh_attempted,+ use_responses_lite,+ retries,+ },+ ctx.clone(),+ ))+ }++ async fn start_http_event_attempt(+ &self,+ auth: &mut StoredAuth,+ body_json: &str,+ ctx: &RequestContext,+ use_responses_lite: bool,+ auth_refresh_attempted: &mut bool,+ ) -> Result<(reqwest::Response, Instant), CodexError> {+ loop {+ let (resp, started_at) = self+ .start_post_http(auth, body_json, ctx, use_responses_lite)+ .await?;++ if resp.status().as_u16() == 401 && !*auth_refresh_attempted {+ *auth_refresh_attempted = true;+ *auth = self+ .auth_manager+ .force_refresh(&auth.access)+ .await+ .map_err(auth_refresh_error)?;+ continue;+ }++ if !resp.status().is_success() {+ let response = self.collect_http_response(resp, started_at, ctx).await?;+ let mut error = codex_status_error(response);+ error.origin = CodexErrorOrigin::Http;+ return Err(error);+ }++ let status = resp.status().as_u16();+ let headers = response_headers(&resp);+ if let Some(traffic) = ctx.traffic.as_deref() {+ write_upstream_response_headers_capture(+ traffic,+ status,+ started_at.elapsed(),+ &headers,+ );+ }+ return Ok((resp, started_at));+ }+ }++ pub async fn stream_codex_auto_events(+ self: &Arc<Self>,+ body: &ResponsesRequest,+ ctx: &RequestContext,+ continuation: Option<&super::continuation::ContinuationCandidate>,+ ) -> Result<super::websocket::CodexWebSocketEventReceiver, CodexError> {+ let mut websocket = self+ .stream_codex_websocket_events(body, ctx, continuation)+ .await?;+ let client = self.clone();+ let body = body.clone();+ let ctx = ctx.clone();+ let (tx, rx) = tokio::sync::mpsc::channel(64);+ tokio::spawn(async move {+ match websocket.recv().await {+ Some(Err(err)) if should_fallback_to_http(&err) => {+ match client.stream_codex_http_events(&body, &ctx).await {+ Ok(http) => forward_codex_events(http, tx).await,+ Err(err) => {+ let _ = tx.send(Err(err)).await;+ }+ }+ }+ Some(item) => {+ if tx.send(item).await.is_ok() {+ forward_codex_events(websocket, tx).await;+ }+ }+ None => {+ let _ = tx+ .send(Err(CodexError {+ status: 0,+ message: "WebSocket connection closed before the first Codex event"+ .to_string(),+ detail: Some(+ super::websocket::WEBSOCKET_MISSING_TERMINAL_DETAIL.to_string(),+ ),+ retry_after: None,+ origin: CodexErrorOrigin::WebSocket,+ }))+ .await;+ }+ }+ });+ Ok(rx)+ }++ fn spawn_http_event_stream(+ self: &Arc<Self>,+ state: HttpEventStreamState,+ ctx: RequestContext,+ ) -> CodexHttpEventReceiver {+ let HttpEventStreamState {+ mut resp,+ mut started_at,+ body_json,+ mut auth,+ mut auth_refresh_attempted,+ use_responses_lite,+ mut retries,+ } = state;+ let client = self.clone();+ let body_idle_timeout_ms = self.body_idle_timeout_ms;+ let req_id = ctx.req_id.clone();+ let traffic = ctx.traffic.clone();+ let (tx, rx) = tokio::sync::mpsc::channel(64);++ tokio::spawn(async move {+ let log = create_logger("codex");+ let mut semantic_output_forwarded = false;++ if tx+ .send(Ok(serde_json::json!({+ "type": "keepalive",+ "_ccp_synthetic": true+ })))+ .await+ .is_err()+ {+ return;+ }++ 'attempts: loop {+ let mut decoder = HttpSseDecoder::default();+ let mut body_bytes = 0_u64;+ let mut body_chunks = 0_u64;+ let mut event_count = 0_u64;+ let mut pending_events = Vec::new();++ let mut retry_error = 'read_attempt: loop {+ let chunk = tokio::select! {+ _ = tx.closed() => {+ log_http_stream_end(+ &log,+ "codex_http_stream_dropped",+ &req_id,+ started_at,+ body_bytes,+ body_chunks,+ event_count,+ None,+ );+ return;+ }+ chunk = tokio::time::timeout(+ Duration::from_millis(body_idle_timeout_ms),+ resp.chunk(),+ ) => chunk+ };++ let chunk = match chunk {+ Ok(Ok(Some(chunk))) => chunk,+ Ok(Ok(None)) => {+ let error = match decoder.finish() {+ Ok(()) => http_sse_error(+ "Codex SSE stream ended before a terminal response event",+ ),+ Err(error) => error,+ };+ log_http_stream_end(+ &log,+ "codex_http_stream_failed",+ &req_id,+ started_at,+ body_bytes,+ body_chunks,+ event_count,+ Some(&error.message),+ );+ if !semantic_output_forwarded && retryable_http_stream_error(&error) {+ break 'read_attempt error;+ }+ let _ = tx.send(Err(error)).await;+ return;+ }+ Ok(Err(err)) => {+ let error = CodexError {+ status: 0,+ message: format!(+ "Transport error reading Codex response body: {err}"+ ),+ detail: Some("http_response_body".to_string()),+ retry_after: None,+ origin: CodexErrorOrigin::Http,+ };+ log_http_stream_end(+ &log,+ "codex_http_stream_failed",+ &req_id,+ started_at,+ body_bytes,+ body_chunks,+ event_count,+ Some(&error.message),+ );+ if !semantic_output_forwarded {+ break 'read_attempt error;+ }+ let _ = tx.send(Err(error)).await;+ return;+ }+ Err(_) => {+ let error = CodexError {+ status: 0,+ message: format!(+ "Timed out waiting {body_idle_timeout_ms}ms for the next Codex response body chunk"+ ),+ detail: Some("http_response_body".to_string()),+ retry_after: None,+ origin: CodexErrorOrigin::Http,+ };+ log_http_stream_end(+ &log,+ "codex_http_stream_failed",+ &req_id,+ started_at,+ body_bytes,+ body_chunks,+ event_count,+ Some(&error.message),+ );+ if !semantic_output_forwarded {+ break 'read_attempt error;+ }+ let _ = tx.send(Err(error)).await;+ return;+ }+ };++ body_bytes = body_bytes.saturating_add(chunk.len() as u64);+ body_chunks = body_chunks.saturating_add(1);+ let events = match decoder.push(&chunk) {+ Ok(events) => events,+ Err(error) => {+ log_http_stream_end(+ &log,+ "codex_http_stream_failed",+ &req_id,+ started_at,+ body_bytes,+ body_chunks,+ event_count,+ Some(&error.message),+ );+ if !semantic_output_forwarded && retryable_http_stream_error(&error) {+ break 'read_attempt error;+ }+ let _ = tx.send(Err(error)).await;+ return;+ }+ };++ for event in events {+ let Some(payload) = event.payload else {+ continue;+ };+ event_count = event_count.saturating_add(1);+ if let Some(traffic) = traffic.as_deref() {+ write_codex_http_sse_event_capture(+ traffic,+ event.event.as_deref(),+ &payload,+ );+ }++ let failure = super::events::classify_event_failure(&payload);+ if !semantic_output_forwarded+ && let Some(failure) = failure.as_ref()+ && failure.retryable()+ {+ pending_events.clear();+ break 'read_attempt codex_event_failure_error(failure.clone());+ }++ let terminal = event_closes_http_stream(&payload);+ if !semantic_output_forwarded && failure.is_some() {+ pending_events.clear();+ if tx.send(Ok(payload)).await.is_err() {+ return;+ }+ } else if !semantic_output_forwarded+ && http_event_starts_semantic_output(&payload)+ {+ semantic_output_forwarded = true;+ for pending in pending_events.drain(..) {+ if tx.send(Ok(pending)).await.is_err() {+ return;+ }+ }+ if tx.send(Ok(payload)).await.is_err() {+ return;+ }+ } else if semantic_output_forwarded || http_event_is_control(&payload) {+ if tx.send(Ok(payload)).await.is_err() {+ return;+ }+ } else {+ pending_events.push(payload);+ }++ if terminal {+ log_http_stream_end(+ &log,+ "codex_http_stream_completed",+ &req_id,+ started_at,+ body_bytes,+ body_chunks,+ event_count,+ None,+ );+ return;+ }+ }+ };++ loop {+ if retries >= MAX_BUFFERED_TRANSPORT_RETRIES {+ let _ = tx.send(Err(retry_error)).await;+ return;+ }+ let delay = compute_backoff_delay(retries, retry_error.retry_after.as_deref());+ if delay.exceeds_budget {+ let _ = tx.send(Err(retry_error)).await;+ return;+ }+ retries += 1;+ tokio::select! {+ _ = tx.closed() => return,+ _ = sleep(delay.wait_ms) => {}+ }++ let next_attempt = tokio::select! {+ _ = tx.closed() => return,+ result = client.start_http_event_attempt(+ &mut auth,+ &body_json,+ &ctx,+ use_responses_lite,+ &mut auth_refresh_attempted,+ ) => result+ };+ match next_attempt {+ Ok((next_resp, next_started_at)) => {+ resp = next_resp;+ started_at = next_started_at;+ continue 'attempts;+ }+ Err(error) if retryable_http_stream_error(&error) => {+ retry_error = error;+ }+ Err(error) => {+ let _ = tx.send(Err(error)).await;+ return;+ }+ }+ }+ }+ });++ rx+ }+async fn post_codex_with_transport(&self,body: &ResponsesRequest,@@ -1485,6 +2044,19 @@ impl CodexHttpClient {ctx: &RequestContext,use_responses_lite: bool,) -> Result<CodexResponse, CodexError> {+ let (resp, started_at) = self+ .start_post_http(auth, body_json, ctx, use_responses_lite)+ .await?;+ self.collect_http_response(resp, started_at, ctx).await+ }++ async fn start_post_http(+ &self,+ auth: &StoredAuth,+ body_json: &str,+ ctx: &RequestContext,+ use_responses_lite: bool,+ ) -> Result<(reqwest::Response, Instant), CodexError> {let url = &self.base_url;let headers = build_codex_headers(auth, ctx, use_responses_lite)?;@@ -1503,7 +2075,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 mut resp = tokio::time::timeout(header_timeout_dur, send_fut)+ let resp = tokio::time::timeout(header_timeout_dur, send_fut).await.map_err(|_| CodexError {status: 0,@@ -1535,6 +2107,15 @@ impl CodexHttpClient {}})?;+ Ok((resp, started_at))+ }++ async fn collect_http_response(+ &self,+ mut resp: reqwest::Response,+ started_at: Instant,+ ctx: &RequestContext,+ ) -> Result<CodexResponse, CodexError> {let status = resp.status().as_u16();let headers: Vec<(String, String)> = resp.headers()@@ -1700,6 +2281,136 @@ impl CodexHttpClient {}}+async fn forward_codex_events(+ mut source: tokio::sync::mpsc::Receiver<Result<serde_json::Value, CodexError>>,+ tx: tokio::sync::mpsc::Sender<Result<serde_json::Value, CodexError>>,+) {+ while let Some(item) = source.recv().await {+ if tx.send(item).await.is_err() {+ return;+ }+ }+}++fn response_headers(resp: &reqwest::Response) -> Vec<(String, String)> {+ resp.headers()+ .iter()+ .map(|(key, value)| (key.to_string(), value.to_str().unwrap_or("").to_string()))+ .collect()+}++fn event_closes_http_stream(payload: &serde_json::Value) -> bool {+ matches!(+ payload.get("type").and_then(|value| value.as_str()),+ Some(+ "response.completed"+ | "response.incomplete"+ | "response.done"+ | "response.failed"+ | "response.error"+ | "error"+ )+ )+}++fn http_event_is_control(payload: &serde_json::Value) -> bool {+ matches!(+ payload.get("type").and_then(|value| value.as_str()),+ Some(+ "keepalive"+ | "response.created"+ | "response.in_progress"+ | "codex.rate_limits"+ | "response.web_search_call.in_progress"+ | "response.web_search_call.searching"+ | "response.web_search_call.completed"+ )+ )+}++fn http_event_starts_semantic_output(payload: &serde_json::Value) -> bool {+ match payload.get("type").and_then(|value| value.as_str()) {+ Some("response.output_item.added") => matches!(+ payload+ .pointer("/item/type")+ .and_then(|value| value.as_str()),+ Some("message" | "function_call")+ ),+ Some(+ "response.reasoning_summary_text.delta"+ | "response.output_text.delta"+ | "response.function_call_arguments.delta",+ ) => payload+ .get("delta")+ .and_then(|value| value.as_str())+ .is_some_and(|delta| !delta.is_empty()),+ Some("response.output_item.done") => matches!(+ payload+ .pointer("/item/type")+ .and_then(|value| value.as_str()),+ Some("reasoning" | "message" | "function_call")+ ),+ Some("response.completed" | "response.incomplete" | "response.done") => true,+ _ => false,+ }+}++fn codex_event_failure_error(failure: super::events::CodexEventFailure) -> CodexError {+ CodexError {+ status: failure.status,+ message: failure.message.clone(),+ detail: Some(failure.message),+ retry_after: failure.retry_after,+ origin: CodexErrorOrigin::Http,+ }+}++fn retryable_http_stream_error(error: &CodexError) -> bool {+ if should_retry_codex_status(error.status) || is_retryable_transport_error(error) {+ return true;+ }+ if error.status != 0 {+ return false;+ }+ if error.detail.as_deref() == Some("http_response_sse") {+ return error.message != "Codex SSE frame exceeds the size limit";+ }+ let message = error.message.to_ascii_lowercase();+ message.contains("ended before a terminal response event")+ || message.contains("ended with an incomplete frame")+}++#[allow(clippy::too_many_arguments)]+fn log_http_stream_end(+ log: &crate::logging::Logger,+ message: &str,+ req_id: &str,+ started_at: Instant,+ body_bytes: u64,+ body_chunks: u64,+ event_count: u64,+ error: Option<&str>,+) {+ let mut fields = serde_json::Map::from_iter([+ ("reqId".to_string(), serde_json::json!(req_id)),+ ("transport".to_string(), serde_json::json!("http")),+ ("bodyBytes".to_string(), serde_json::json!(body_bytes)),+ ("bodyChunks".to_string(), serde_json::json!(body_chunks)),+ ("eventCount".to_string(), serde_json::json!(event_count)),+ (+ "ms".to_string(),+ serde_json::json!(started_at.elapsed().as_millis()),+ ),+ ]);+ if let Some(error) = error {+ fields.insert("error".to_string(), serde_json::json!(error));+ }+ match message {+ "codex_http_stream_completed" => log.info(message, Some(fields)),+ _ => log.warn(message, Some(fields)),+ }+}+fn write_codex_http_request_capture(traffic: &TrafficCapture,url: &str,@@ -1747,6 +2458,21 @@ fn write_upstream_response_capture(elapsed: Duration,headers: &[(String, String)],body: &[u8],+) {+ write_upstream_response_headers_capture(traffic, status, elapsed, headers);+ if status >= 400 {+ traffic.write_text("031-upstream-error-body", &String::from_utf8_lossy(body));+ } else {+ traffic.write_bytes("032-upstream-response-body.sse", body);+ write_codex_sse_event_capture(traffic, body);+ }+}++fn write_upstream_response_headers_capture(+ traffic: &TrafficCapture,+ status: u16,+ elapsed: Duration,+ headers: &[(String, String)],) {traffic.write_json("030-upstream-response-headers",@@ -1756,12 +2482,22 @@ fn write_upstream_response_capture("headers": headers_to_json_from_pairs(headers),}),);- if status >= 400 {- traffic.write_text("031-upstream-error-body", &String::from_utf8_lossy(body));- } else {- traffic.write_bytes("032-upstream-response-body.sse", body);- write_codex_sse_event_capture(traffic, body);+}++fn write_codex_http_sse_event_capture(+ traffic: &TrafficCapture,+ event: Option<&str>,+ payload: &serde_json::Value,+) {+ let mut payload = payload.clone();+ if let Some(event) = event+ && let Some(object) = payload.as_object_mut()+ {+ object+ .entry("_sse_event")+ .or_insert_with(|| serde_json::json!(event));}+ traffic.write_json_event("040-upstream-event", &payload);}fn write_codex_sse_event_capture(traffic: &TrafficCapture, body: &[u8]) {@@ -2338,6 +3074,160 @@ mod tests {server.await.unwrap();}+ async fn write_http_chunk(stream: &mut tokio::net::TcpStream, body: &[u8]) {+ stream+ .write_all(format!("{:x}\r\n", body.len()).as_bytes())+ .await+ .unwrap();+ stream.write_all(body).await.unwrap();+ stream.write_all(b"\r\n").await.unwrap();+ stream.flush().await.unwrap();+ }++ #[test]+ fn http_sse_decoder_handles_fragmented_crlf_and_done_marker() {+ let mut decoder = HttpSseDecoder::default();+ assert!(+ decoder+ .push(b"event: response.output_text.delta\r")+ .unwrap()+ .is_empty()+ );+ let events = decoder+ .push(b"\ndata: {\"type\":\"response.output_text.delta\",\"delta\":\"ok\"}\r\n\r\n")+ .unwrap();+ assert_eq!(events.len(), 1);+ assert_eq!(+ events[0].event.as_deref(),+ Some("response.output_text.delta")+ );+ assert_eq!(+ events[0]+ .payload+ .as_ref()+ .and_then(|payload| payload.get("delta"))+ .and_then(|value| value.as_str()),+ Some("ok")+ );++ let done = decoder.push(b"data: [DONE]\n\n").unwrap();+ assert_eq!(done.len(), 1);+ assert!(done[0].payload.is_none());+ decoder.finish().unwrap();+ }++ #[test]+ fn http_sse_size_limit_is_not_retryable() {+ assert!(!retryable_http_stream_error(&http_sse_error(+ "Codex SSE frame exceeds the size limit",+ )));+ assert!(retryable_http_stream_error(&http_sse_error(+ "Codex SSE frame contains invalid JSON",+ )));+ assert!(retryable_http_stream_error(&http_sse_error(+ "Codex SSE frame contains invalid UTF-8",+ )));+ }++ #[tokio::test]+ async fn http_stream_forwards_event_before_terminal_body() {+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();+ let addr = listener.local_addr().unwrap();+ let (release_tx, release_rx) = tokio::sync::oneshot::channel();+ let server = tokio::spawn(async move {+ let (mut stream, _) = listener.accept().await.unwrap();+ let mut request = [0_u8; 16 * 1024];+ assert!(stream.read(&mut request).await.unwrap() > 0);+ stream+ .write_all(+ b"HTTP/1.1 200 OK\r\ncontent-type: text/event-stream\r\ntransfer-encoding: chunked\r\nconnection: close\r\n\r\n",+ )+ .await+ .unwrap();+ write_http_chunk(+ &mut stream,+ b"data: {\"type\":\"response.output_item.added\",\"output_index\":0,\"item\":{\"type\":\"message\",\"id\":\"msg_up\"}}\n\n",+ )+ .await;+ release_rx.await.unwrap();+ write_http_chunk(+ &mut stream,+ b"data: {\"type\":\"response.completed\",\"response\":{\"id\":\"resp_1\",\"status\":\"completed\",\"usage\":{}}}\n\n",+ )+ .await;+ });++ let client = Arc::new(http_test_client(format!("http://{addr}/responses"), 1_000));+ client.auth_manager().set_test_auth(http_test_auth());+ let mut events = client+ .stream_codex_http_events(&buffered_test_request(), &http_test_context())+ .await+ .unwrap();++ let synthetic = events.recv().await.unwrap().unwrap();+ assert_eq!(+ synthetic.get("type").and_then(|value| value.as_str()),+ Some("keepalive")+ );+ let first_upstream = tokio::time::timeout(Duration::from_millis(200), events.recv())+ .await+ .expect("first upstream event must arrive before the response completes")+ .unwrap()+ .unwrap();+ assert_eq!(+ first_upstream.get("type").and_then(|value| value.as_str()),+ Some("response.output_item.added")+ );++ release_tx.send(()).unwrap();+ let terminal = events.recv().await.unwrap().unwrap();+ assert_eq!(+ terminal.get("type").and_then(|value| value.as_str()),+ Some("response.completed")+ );+ server.await.unwrap();+ }++ #[tokio::test]+ async fn http_stream_bounds_initial_status_retries() {+ 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 attempts = 0_u32;+ while let Ok(Ok((mut stream, _))) =+ tokio::time::timeout(Duration::from_millis(100), listener.accept()).await+ {+ let mut request = [0_u8; 16 * 1024];+ assert!(stream.read(&mut request).await.unwrap() > 0);+ attempts += 1;+ stream+ .write_all(+ b"HTTP/1.1 503 Service Unavailable\r\ncontent-length: 0\r\nretry-after: 0\r\nconnection: close\r\n\r\n",+ )+ .await+ .unwrap();+ }+ attempts+ });++ let client = Arc::new(http_test_client(format!("http://{addr}/responses"), 1_000));+ client.auth_manager().set_test_auth(http_test_auth());+ let error = match client+ .stream_codex_http_events(&buffered_test_request(), &http_test_context())+ .await+ {+ Ok(_) => panic!("retryable status must exhaust with an error"),+ Err(error) => error,+ };++ assert_eq!(error.status, 503);+ assert_eq!(+ server.await.unwrap(),+ MAX_BUFFERED_TRANSPORT_ATTEMPTS,+ "initial status failures must share the HTTP stream retry budget"+ );+ }+#[tokio::test]async fn native_responses_replaces_auth_and_preserves_json_body() {let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();diff --git a/src/providers/codex/mod.rs b/src/providers/codex/mod.rsindex d253425..0ff26aa 100644--- a/src/providers/codex/mod.rs+++ b/src/providers/codex/mod.rs@@ -20,7 +20,7 @@ use axum::response::{IntoResponse, Response};use bytes::Bytes;use http::StatusCode;use std::sync::Arc;-use std::time::Instant;+use std::time::{Duration, Instant};use crate::anthropic::error::json_error;use crate::anthropic::schema::{CountTokensResponse, MessagesRequest};@@ -59,6 +59,7 @@ use self::translate::request::{const MAX_RETRYABLE_LIVE_STREAM_RETRIES: u32 = 10;const MAX_EMPTY_COMPLETION_RETRIES: u32 = 10;const EMPTY_CODEX_COMPLETION_DETAIL: &str = "empty_codex_completion";+const LIVE_STREAM_HEARTBEAT_INTERVAL: Duration = Duration::from_secs(15);use self::translate::stream::translate_stream_bytes_with_traffic;// ---------------------------------------------------------------------------@@ -297,15 +298,46 @@ impl Provider for CodexProvider {previous_response_id_enabled,);let turn_id = continuation.turn_id;+ let configured_transport = config::codex_transport();+ let transport = configured_transport.as_str();+ let upstream_started_at = Instant::now();+ let log = create_logger("codex");+ let req_id = ctx.req_id.clone();+ log.info(+ "codex_upstream_request_started",+ Some(serde_json::Map::from_iter([+ ("reqId".to_string(), serde_json::json!(&req_id)),+ ("transport".to_string(), serde_json::json!(transport)),+ ("model".to_string(), serde_json::json!(&resolved.model)),+ ("stream".to_string(), serde_json::json!(want_stream)),+ (+ "responsesLite".to_string(),+ serde_json::json!(use_responses_lite),+ ),+ (+ "previousResponseIdEnabled".to_string(),+ serde_json::json!(previous_response_id_enabled),+ ),+ (+ "hasPreviousResponseId".to_string(),+ serde_json::json!(continuation.previous_response_id.is_some()),+ ),+ (+ "inputDeltaCount".to_string(),+ serde_json::json!(continuation.input_delta.as_ref().map(Vec::len)),+ ),+ ("turnId".to_string(), serde_json::json!(turn_id)),+ ])),+ );// Post to upstream with continuationlet client = self.client.clone();if let Some(monitor) = ctx.monitor.as_ref() {monitor.upstream_started(&ctx.req_id);}- if want_stream && matches!(config::codex_transport(), config::CodexTransport::WebSocket) {+ if want_stream {let stream_request = translated.clone();- return live_stream_response(+ let response = live_stream_response(client,message_id,model,@@ -316,8 +348,25 @@ impl Provider for CodexProvider {compact_boundary,attempt: compaction_attempt,},+ configured_transport,).await;+ log.info(+ "codex_upstream_response_ready",+ Some(serde_json::Map::from_iter([+ ("reqId".to_string(), serde_json::json!(&req_id)),+ ("transport".to_string(), serde_json::json!(transport)),+ (+ "status".to_string(),+ serde_json::json!(response.status().as_u16()),+ ),+ (+ "ms".to_string(),+ serde_json::json!(upstream_started_at.elapsed().as_millis()),+ ),+ ])),+ );+ return response;}let mut continuation = Some(continuation);@@ -329,6 +378,23 @@ impl Provider for CodexProvider {{Ok(r) => r,Err(e) => {+ log.warn(+ "codex_upstream_request_failed",+ Some(serde_json::Map::from_iter([+ ("reqId".to_string(), serde_json::json!(&req_id)),+ ("transport".to_string(), serde_json::json!(transport)),+ ("status".to_string(), serde_json::json!(e.status)),+ (+ "origin".to_string(),+ serde_json::json!(format!("{:?}", e.origin)),+ ),+ ("error".to_string(), serde_json::json!(&e.message)),+ (+ "ms".to_string(),+ serde_json::json!(upstream_started_at.elapsed().as_millis()),+ ),+ ])),+ );abort_compaction_attempt(ctx.session_id.as_deref(), compaction_attempt);abort_continuation(ctx.session_id.as_deref(), turn_id);return map_codex_error_to_response(&e);@@ -355,6 +421,22 @@ impl Provider for CodexProvider {attempt += 1;sleep(delay.wait_ms).await;};+ log.info(+ "codex_upstream_response_received",+ Some(serde_json::Map::from_iter([+ ("reqId".to_string(), serde_json::json!(&req_id)),+ ("transport".to_string(), serde_json::json!(transport)),+ ("status".to_string(), serde_json::json!(upstream.status)),+ (+ "bodyBytes".to_string(),+ serde_json::json!(upstream.body.len()),+ ),+ (+ "ms".to_string(),+ serde_json::json!(upstream_started_at.elapsed().as_millis()),+ ),+ ])),+ );if want_stream {let estimated_input_tokens = count_translated_tokens(&translated);@@ -539,6 +621,7 @@ struct LiveStreamCompaction {attempt: Option<CompactionAttempt>,}+#[allow(clippy::too_many_arguments)]async fn live_stream_response(client: Arc<CodexHttpClient>,message_id: String,@@ -547,6 +630,7 @@ async fn live_stream_response(request_body: translate::request::ResponsesRequest,continuation: ContinuationCandidate,compaction: LiveStreamCompaction,+ transport: config::CodexTransport,) -> Response {let model = model.to_string();let turn_id = continuation.turn_id;@@ -554,11 +638,27 @@ async fn live_stream_response(let mut continuation = Some(continuation);loop {- let upstream_events = match client- .stream_codex_websocket_events(&request_body, &ctx, continuation.as_ref())- .await- {+ let upstream_events = match transport {+ config::CodexTransport::Http => {+ client.stream_codex_http_events(&request_body, &ctx).await+ }+ config::CodexTransport::WebSocket => {+ client+ .stream_codex_websocket_events(&request_body, &ctx, continuation.as_ref())+ .await+ }+ config::CodexTransport::Auto => {+ client+ .stream_codex_auto_events(&request_body, &ctx, continuation.as_ref())+ .await+ }+ };+ let upstream_events = match upstream_events {Ok(events) => events,+ Err(err) if err.origin == client::CodexErrorOrigin::Http => {+ abort_request_state(ctx.session_id.as_deref(), turn_id, compaction.attempt);+ return map_codex_error_to_response(&err);+ }Err(err) if retryable_live_start_codex_error(&err) => {let dropped = drop_live_continuation_for_retry(&mut continuation);if dropped && is_missing_previous_response_error(&err) {@@ -597,6 +697,14 @@ async fn live_stream_response({LiveStreamStart::Response(response) => return response,LiveStreamStart::Retry { error } => {+ // The incremental HTTP reader performs its own bounded+ // pre-semantic retries so it can stop immediately when the+ // consumer disappears. Do not multiply that exhausted retry+ // loop by the provider-level WebSocket retry policy.+ if error.origin == client::CodexErrorOrigin::Http {+ abort_request_state(ctx.session_id.as_deref(), turn_id, compaction.attempt);+ return map_codex_error_to_response(&error);+ }let dropped = drop_live_continuation_for_retry(&mut continuation);if dropped && is_missing_previous_response_error(&error) {attempt += 1;@@ -846,7 +954,31 @@ fn remaining_live_stream_response(abort_request_state(ctx.session_id.as_deref(), turn_id, compaction.attempt);return;}- while let Some(item) = upstream_events.recv().await {+ let mut heartbeat = tokio::time::interval(LIVE_STREAM_HEARTBEAT_INTERVAL);+ heartbeat.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);+ heartbeat.tick().await;+ loop {+ let item = tokio::select! {+ _ = tx.closed() => {+ abort_continuation(ctx.session_id.as_deref(), turn_id);+ return;+ }+ item = upstream_events.recv() => item,+ _ = heartbeat.tick() => {+ let chunk = translator.ping_chunk(ctx.traffic.as_deref());+ if !chunk.is_empty() {+ record_live_stream_progress(&ctx, &chunk);+ if tx.send(Ok(Bytes::from(chunk))).await.is_err() {+ abort_continuation(ctx.session_id.as_deref(), turn_id);+ return;+ }+ }+ continue;+ }+ };+ let Some(item) = item else {+ break;+ };match item {Ok(payload) => {append_upstream_sse_payload(&mut upstream_sse_body, &payload);@@ -929,7 +1061,7 @@ fn remaining_live_stream_response(return;}let chunk = translator.error_chunk(- "WebSocket connection closed before terminal Codex response event",+ "Upstream event stream closed before terminal Codex response event","api_error",ctx.traffic.as_deref(),);@@ -1502,6 +1634,123 @@ mod tests {assert_eq!(state.active[0].output_tokens, Some(48));}+ #[tokio::test]+ async fn live_stream_response_emits_downstream_frames_before_terminal_event() {+ use http_body_util::BodyExt as _;++ let body = request_with_tools(serde_json::json!([]));+ let request_body = translate_request(+ &body,+ TranslateOptions {+ session_id: None,+ service_tier: None,+ model: "gpt-5.6-sol".to_string(),+ use_responses_lite: true,+ },+ )+ .unwrap();+ let ctx = RequestContext {+ req_id: "incremental-http".to_string(),+ session_id: None,+ session_seq: None,+ provider: "codex".to_string(),+ traffic: None,+ monitor: None,+ };+ let (tx, rx) = tokio::sync::mpsc::channel(8);+ tx.send(Ok(serde_json::json!({"type": "keepalive"})))+ .await+ .unwrap();+ tx.send(Ok(serde_json::json!({+ "type": "response.output_item.added",+ "output_index": 0,+ "item": {"type": "message", "id": "msg_up"}+ })))+ .await+ .unwrap();+ tx.send(Ok(serde_json::json!({+ "type": "response.output_text.delta",+ "output_index": 0,+ "delta": "first"+ })))+ .await+ .unwrap();++ let response = match live_stream_response_once(+ rx,+ "msg_test".to_string(),+ "claude-opus-4-8",+ ctx,+ None,+ request_body,+ LiveStreamCompaction {+ compact_boundary: false,+ attempt: None,+ },+ )+ .await+ {+ LiveStreamStart::Response(response) => response,+ LiveStreamStart::Retry { error } => panic!("unexpected retry: {error}"),+ };+ let mut body = response.into_body();+ let first = tokio::time::timeout(Duration::from_millis(200), body.frame())+ .await+ .expect("initial downstream frame must be available immediately")+ .unwrap()+ .unwrap()+ .into_data()+ .unwrap();+ let first = String::from_utf8(first.to_vec()).unwrap();+ assert!(first.contains("event: message_start"));+ assert!(first.contains("event: ping"));+ assert!(first.contains("event: content_block_start"));+ assert!(first.contains("event: content_block_delta"));++ tx.send(Ok(serde_json::json!({+ "type": "response.output_text.delta",+ "output_index": 0,+ "delta": "second"+ })))+ .await+ .unwrap();+ let second = tokio::time::timeout(Duration::from_millis(200), body.frame())+ .await+ .expect("text delta must arrive before the terminal event")+ .unwrap()+ .unwrap()+ .into_data()+ .unwrap();+ assert!(+ String::from_utf8(second.to_vec())+ .unwrap()+ .contains("event: content_block_delta")+ );++ for payload in [+ serde_json::json!({+ "type": "response.output_item.done",+ "output_index": 0,+ "item": {"type": "message"}+ }),+ serde_json::json!({+ "type": "response.completed",+ "response": {+ "id": "resp_1",+ "status": "completed",+ "incomplete_details": null,+ "usage": {"input_tokens": 1, "output_tokens": 1}+ }+ }),+ ] {+ tx.send(Ok(payload)).await.unwrap();+ }+ drop(tx);+ while let Some(frame) = body.frame().await {+ frame.unwrap();+ }+ }+#[test]fn supported_models_includes_fast_variants() {let provider = CodexProvider::new();diff --git a/src/providers/codex/translate/live_stream.rs b/src/providers/codex/translate/live_stream.rsindex badbaf3..8a20163 100644--- a/src/providers/codex/translate/live_stream.rs+++ b/src/providers/codex/translate/live_stream.rs@@ -117,8 +117,11 @@ impl LiveStreamTranslator {if is_terminal_rate_limit_event(payload) {return Err("rate limit reached".to_string());}+ self.emit_ping(traffic, &mut out);+ }+ "keepalive" | "response.created" | "response.in_progress" => {+ self.emit_ping(traffic, &mut out);}- "keepalive" => {}"response.failed" | "response.error" | "error" => {return Err(error_message(payload));}@@ -181,6 +184,14 @@ impl LiveStreamTranslator {self.semantic_output_started}+ pub fn ping_chunk(&mut self, traffic: Option<&TrafficCapture>) -> Vec<u8> {+ let mut out = Vec::new();+ if !self.finished {+ self.emit_ping(traffic, &mut out);+ }+ out+ }+pub fn finish_after_closed_completed_tool_call(&mut self,traffic: Option<&TrafficCapture>,@@ -251,6 +262,11 @@ impl LiveStreamTranslator {);}+ fn emit_ping(&mut self, traffic: Option<&TrafficCapture>, out: &mut Vec<u8>) {+ self.ensure_message_start(traffic, out);+ self.emit(traffic, out, "ping", &serde_json::json!({"type": "ping"}));+ }+fn emit(&self,traffic: Option<&TrafficCapture>,@@ -1544,6 +1560,23 @@ mod tests {assert_eq!(err, "rate limit reached");}+ #[test]+ fn progress_events_start_message_and_emit_pings() {+ let mut translator = LiveStreamTranslator::new("msg_1", "gpt-5.5");+ let first = String::from_utf8(+ translator+ .accept(&json!({"type": "response.created"}), None)+ .unwrap(),+ )+ .unwrap();+ assert_eq!(first.matches("event: message_start").count(), 1);+ assert_eq!(first.matches("event: ping").count(), 1);++ let second = String::from_utf8(translator.ping_chunk(None)).unwrap();+ assert!(!second.contains("event: message_start"));+ assert_eq!(second.matches("event: ping").count(), 1);+ }+#[test]fn live_stream_emits_signature_delta_before_thinking_stop() {let out = render(vec![diff --git a/tests/smoke_cutover.rs b/tests/smoke_cutover.rsindex 7bbd602..237f9cb 100644--- a/tests/smoke_cutover.rs+++ b/tests/smoke_cutover.rs@@ -15,6 +15,7 @@ use futures_util::{SinkExt, StreamExt};use http_body_util::BodyExt;use serde_json::{Value, json};use std::path::{Path, PathBuf};+use std::sync::atomic::{AtomicUsize, Ordering};use std::sync::{Arc, Mutex, OnceLock};use std::time::Duration;use tempfile::TempDir;@@ -195,6 +196,63 @@ whereaddr_str}+#[allow(clippy::await_holding_lock)]+async fn assert_codex_http_presemantic_retry(first_response: Vec<u8>) {+ let _guard = env_lock();+ clear_all_continuations_for_tests();+ let config = TempDir::new().unwrap();+ write_auth(config.path(), "codex");++ let attempts = Arc::new(AtomicUsize::new(0));+ let first_response = Arc::new(first_response);+ let upstream = spawn_http_upstream({+ let attempts = attempts.clone();+ let first_response = first_response.clone();+ move |_body: Value| {+ if attempts.fetch_add(1, Ordering::SeqCst) == 0 {+ first_response.as_ref().clone()+ } else {+ concat!(+ "data: {\"type\":\"response.created\",\"response\":{\"id\":\"resp_retry\"}}\n\n",+ "data: {\"type\":\"response.output_item.added\",\"output_index\":0,\"item\":{\"type\":\"message\",\"id\":\"msg_retry\"}}\n\n",+ "data: {\"type\":\"response.output_text.delta\",\"output_index\":0,\"delta\":\"retry succeeded\"}\n\n",+ "data: {\"type\":\"response.output_item.done\",\"output_index\":0,\"item\":{\"type\":\"message\"}}\n\n",+ "data: {\"type\":\"response.completed\",\"response\":{\"id\":\"resp_retry\",\"status\":\"completed\",\"usage\":{\"input_tokens\":5,\"output_tokens\":2}}}\n\n"+ )+ .as_bytes()+ .to_vec()+ }+ }+ })+ .await;++ let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());+ let _base_url_env = EnvGuard::set("CCP_CODEX_BASE_URL", &upstream);+ let _transport_env = EnvGuard::set("CCP_CODEX_TRANSPORT", "http");+ let response = call_messages_body(json!({+ "model": "gpt-5.5",+ "max_tokens": 64,+ "stream": true,+ "messages": [{"role":"user","content":"hello"}]+ }))+ .await;++ assert_eq!(response.status(), StatusCode::OK);+ let body = tokio::time::timeout(+ Duration::from_secs(2),+ axum::body::to_bytes(response.into_body(), usize::MAX),+ )+ .await+ .expect("retried stream must finish")+ .unwrap();+ let text = String::from_utf8_lossy(&body);+ assert_eq!(attempts.load(Ordering::SeqCst), 2, "stream body: {text}");+ assert!(text.contains("retry succeeded"), "stream body: {text}");+ assert!(!text.contains("event: error"), "stream body: {text}");+ assert_eq!(text.matches("event: message_start").count(), 1);+ assert_eq!(text.matches("event: message_stop").count(), 1);+}+/// Spawn a mock WebSocket server that accepts one connection, captures the/// first text message, and responds with Codex WebSocket events that/// accumulate to `"codex websocket ok"`.@@ -1491,6 +1549,364 @@ async fn smoke_codex_http_stream_traffic_captures_downstream_events() {assert!(downstream.get("data").is_some());}+#[allow(clippy::await_holding_lock)]+#[tokio::test]+async fn smoke_codex_http_stream_returns_before_upstream_completion() {+ let _guard = env_lock();+ let config = TempDir::new().unwrap();+ write_auth(config.path(), "codex");++ let release = Arc::new(tokio::sync::Notify::new());+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();+ let addr = listener.local_addr().unwrap();+ let upstream = format!("http://{addr}");+ let mock = axum::Router::new().fallback({+ let release = release.clone();+ move |_body: String| {+ let release = release.clone();+ async move {+ let stream = futures_util::stream::unfold(0_u8, move |state| {+ let release = release.clone();+ async move {+ match state {+ 0 => Some((+ Ok::<_, std::convert::Infallible>(bytes::Bytes::from_static(+ concat!(+ "data: {\"type\":\"response.output_item.added\",\"output_index\":0,\"item\":{\"type\":\"message\",\"id\":\"msg_up\"}}\n\n",+ "data: {\"type\":\"response.output_text.delta\",\"output_index\":0,\"delta\":\"incremental ok\"}\n\n"+ )+ .as_bytes(),+ )),+ 1,+ )),+ 1 => {+ release.notified().await;+ Some((+ Ok(bytes::Bytes::from_static(concat!(+ "data: {\"type\":\"response.output_item.done\",\"output_index\":0,\"item\":{\"type\":\"message\"}}\n\n",+ "data: {\"type\":\"response.completed\",\"response\":{\"id\":\"resp_1\",\"status\":\"completed\",\"usage\":{\"input_tokens\":5,\"output_tokens\":2}}}\n\n"+ ).as_bytes())),+ 2,+ ))+ }+ _ => None,+ }+ }+ });+ http::Response::builder()+ .status(StatusCode::OK)+ .header("content-type", "text/event-stream")+ .body(Body::from_stream(stream))+ .unwrap()+ }+ }+ });+ tokio::spawn(async move {+ axum::serve(listener, mock).await.ok();+ });++ let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());+ let _base_url_env = EnvGuard::set("CCP_CODEX_BASE_URL", &upstream);+ let _transport_env = EnvGuard::set("CCP_CODEX_TRANSPORT", "http");+ let response = tokio::time::timeout(+ Duration::from_millis(500),+ call_messages_body(json!({+ "model": "gpt-5.5",+ "max_tokens": 64,+ "stream": true,+ "messages": [{"role":"user","content":"hello"}]+ })),+ )+ .await+ .expect("CCP must return streaming headers before upstream completion");+ assert_eq!(response.status(), StatusCode::OK);++ let mut body = response.into_body();+ let first = tokio::time::timeout(Duration::from_millis(200), body.frame())+ .await+ .expect("initial Anthropic heartbeat must arrive before upstream completion")+ .unwrap()+ .unwrap()+ .into_data()+ .unwrap();+ let first = String::from_utf8(first.to_vec()).unwrap();+ assert!(first.contains("event: message_start"));+ assert!(first.contains("event: ping"));+ assert!(first.contains("incremental ok"));++ release.notify_one();+ let rest = axum::body::to_bytes(body, usize::MAX).await.unwrap();+ let rest = String::from_utf8(rest.to_vec()).unwrap();+ assert!(rest.contains("event: message_stop"), "stream body: {rest}");+}++#[allow(clippy::await_holding_lock)]+#[tokio::test]+async fn smoke_codex_http_retries_overload_after_control_events() {+ assert_codex_http_presemantic_retry(+ concat!(+ "data: {\"type\":\"response.created\",\"response\":{\"id\":\"resp_failed\"}}\n\n",+ "data: {\"type\":\"response.in_progress\",\"response\":{\"id\":\"resp_failed\"}}\n\n",+ "data: {\"type\":\"response.failed\",\"response\":{\"error\":{\"type\":\"overloaded_error\",\"message\":\"Our servers are currently overloaded. Please try again later.\",\"retry_after\":0}}}\n\n"+ )+ .as_bytes()+ .to_vec(),+ )+ .await;+}++#[allow(clippy::await_holding_lock)]+#[tokio::test]+async fn smoke_codex_http_retries_rate_limit_after_control_events() {+ assert_codex_http_presemantic_retry(+ concat!(+ "data: {\"type\":\"response.created\",\"response\":{\"id\":\"resp_limited\"}}\n\n",+ "data: {\"type\":\"codex.rate_limits\",\"rate_limits\":{\"limit_reached\":true,\"primary\":{\"reset_after_seconds\":0}}}\n\n"+ )+ .as_bytes()+ .to_vec(),+ )+ .await;+}++#[allow(clippy::await_holding_lock)]+#[tokio::test]+async fn smoke_codex_http_retries_transient_failure_after_control_events() {+ assert_codex_http_presemantic_retry(+ concat!(+ "data: {\"type\":\"response.created\",\"response\":{\"id\":\"resp_transient\"}}\n\n",+ "data: {\"type\":\"response.failed\",\"response\":{\"error\":{\"type\":\"server_error\",\"status\":503,\"message\":\"temporarily unavailable\",\"retry_after\":0}}}\n\n"+ )+ .as_bytes()+ .to_vec(),+ )+ .await;+}++#[allow(clippy::await_holding_lock)]+#[tokio::test]+async fn smoke_codex_http_retries_presemantic_eof() {+ assert_codex_http_presemantic_retry(+ "data: {\"type\":\"response.created\",\"response\":{\"id\":\"resp_truncated\"}}\n\n"+ .as_bytes()+ .to_vec(),+ )+ .await;+}++#[allow(clippy::await_holding_lock)]+#[tokio::test]+async fn smoke_codex_http_bounds_initial_status_retries() {+ let _guard = env_lock();+ clear_all_continuations_for_tests();+ let config = TempDir::new().unwrap();+ write_auth(config.path(), "codex");++ let attempts = Arc::new(AtomicUsize::new(0));+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();+ let addr = listener.local_addr().unwrap();+ let upstream = format!("http://{addr}");+ let mock = axum::Router::new().fallback({+ let attempts = attempts.clone();+ move || {+ let attempts = attempts.clone();+ async move {+ attempts.fetch_add(1, Ordering::SeqCst);+ http::Response::builder()+ .status(StatusCode::SERVICE_UNAVAILABLE)+ .header("retry-after", "0")+ .body(Body::empty())+ .unwrap()+ }+ }+ });+ tokio::spawn(async move {+ axum::serve(listener, mock).await.ok();+ });++ let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());+ let _base_url_env = EnvGuard::set("CCP_CODEX_BASE_URL", &upstream);+ let _transport_env = EnvGuard::set("CCP_CODEX_TRANSPORT", "http");+ let response = call_messages_body(json!({+ "model": "gpt-5.5",+ "max_tokens": 64,+ "stream": true,+ "messages": [{"role":"user","content":"hello"}]+ }))+ .await;++ assert_eq!(response.status(), StatusCode::SERVICE_UNAVAILABLE);+ assert_eq!(attempts.load(Ordering::SeqCst), 4);+}++#[allow(clippy::await_holding_lock)]+#[tokio::test]+async fn smoke_codex_http_retries_presemantic_invalid_json() {+ assert_codex_http_presemantic_retry(b"data: not-json\n\n".to_vec()).await;+}++#[allow(clippy::await_holding_lock)]+#[tokio::test]+async fn smoke_codex_http_retries_presemantic_invalid_utf8() {+ assert_codex_http_presemantic_retry(b"data: \xff\n\n".to_vec()).await;+}++#[allow(clippy::await_holding_lock)]+#[tokio::test]+async fn smoke_codex_http_does_not_retry_overload_after_semantic_output() {+ let _guard = env_lock();+ let config = TempDir::new().unwrap();+ write_auth(config.path(), "codex");++ let attempts = Arc::new(AtomicUsize::new(0));+ let upstream = spawn_http_upstream({+ let attempts = attempts.clone();+ move |_body: Value| {+ let attempt = attempts.fetch_add(1, Ordering::SeqCst);+ if attempt == 0 {+ concat!(+ "data: {\"type\":\"response.created\",\"response\":{\"id\":\"resp_partial\"}}\n\n",+ "data: {\"type\":\"response.output_item.added\",\"output_index\":0,\"item\":{\"type\":\"message\",\"id\":\"msg_partial\"}}\n\n",+ "data: {\"type\":\"response.output_text.delta\",\"output_index\":0,\"delta\":\"partial output\"}\n\n",+ "data: {\"type\":\"response.failed\",\"response\":{\"error\":{\"type\":\"overloaded_error\",\"message\":\"overloaded after output\",\"retry_after\":0}}}\n\n"+ )+ .as_bytes()+ .to_vec()+ } else {+ panic!("semantic output must close the full-request retry window");+ }+ }+ })+ .await;++ let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());+ let _base_url_env = EnvGuard::set("CCP_CODEX_BASE_URL", &upstream);+ let _transport_env = EnvGuard::set("CCP_CODEX_TRANSPORT", "http");+ let response = call_messages_body(json!({+ "model": "gpt-5.5",+ "max_tokens": 64,+ "stream": true,+ "messages": [{"role":"user","content":"hello"}]+ }))+ .await;++ assert_eq!(response.status(), StatusCode::OK);+ let body = tokio::time::timeout(+ Duration::from_secs(2),+ axum::body::to_bytes(response.into_body(), usize::MAX),+ )+ .await+ .expect("failed semantic stream must terminate")+ .unwrap();+ let text = String::from_utf8_lossy(&body);+ assert_eq!(attempts.load(Ordering::SeqCst), 1, "stream body: {text}");+ assert!(text.contains("partial output"), "stream body: {text}");+ assert!(+ text.contains("overloaded after output"),+ "stream body: {text}"+ );+}++#[allow(clippy::await_holding_lock)]+#[tokio::test]+async fn smoke_codex_http_stops_after_retry_limit() {+ let _guard = env_lock();+ clear_all_continuations_for_tests();+ let config = TempDir::new().unwrap();+ write_auth(config.path(), "codex");++ let attempts = Arc::new(AtomicUsize::new(0));+ let upstream = spawn_http_upstream({+ let attempts = attempts.clone();+ move |_body: Value| {+ attempts.fetch_add(1, Ordering::SeqCst);+ concat!(+ "data: {\"type\":\"response.created\",\"response\":{\"id\":\"resp_exhausted\"}}\n\n",+ "data: {\"type\":\"response.failed\",\"response\":{\"error\":{\"type\":\"overloaded_error\",\"message\":\"overloaded until retry limit\",\"retry_after\":0}}}\n\n"+ )+ .as_bytes()+ .to_vec()+ }+ })+ .await;++ let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());+ let _base_url_env = EnvGuard::set("CCP_CODEX_BASE_URL", &upstream);+ let _transport_env = EnvGuard::set("CCP_CODEX_TRANSPORT", "http");+ let response = call_messages_body(json!({+ "model": "gpt-5.5",+ "max_tokens": 64,+ "stream": true,+ "messages": [{"role":"user","content":"hello"}]+ }))+ .await;++ assert_eq!(response.status().as_u16(), 529);+ let body = tokio::time::timeout(+ Duration::from_secs(2),+ axum::body::to_bytes(response.into_body(), usize::MAX),+ )+ .await+ .expect("exhausted stream must terminate")+ .unwrap();+ let text = String::from_utf8_lossy(&body);+ assert_eq!(attempts.load(Ordering::SeqCst), 4, "stream body: {text}");+ assert!(+ text.contains("overloaded until retry limit"),+ "stream body: {text}"+ );+}++#[allow(clippy::await_holding_lock)]+#[tokio::test]+async fn smoke_codex_http_cancels_retry_backoff_when_request_drops() {+ let _guard = env_lock();+ clear_all_continuations_for_tests();+ let config = TempDir::new().unwrap();+ write_auth(config.path(), "codex");++ let attempts = Arc::new(AtomicUsize::new(0));+ let upstream = spawn_http_upstream({+ let attempts = attempts.clone();+ move |_body: Value| {+ let attempt = attempts.fetch_add(1, Ordering::SeqCst);+ if attempt == 0 {+ concat!(+ "data: {\"type\":\"response.created\",\"response\":{\"id\":\"resp_cancel\"}}\n\n",+ "data: {\"type\":\"response.failed\",\"response\":{\"error\":{\"type\":\"overloaded_error\",\"message\":\"cancel during retry backoff\",\"retry_after\":0.1}}}\n\n"+ )+ .as_bytes()+ .to_vec()+ } else {+ panic!("request cancellation must prevent another upstream attempt");+ }+ }+ })+ .await;++ let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());+ let _base_url_env = EnvGuard::set("CCP_CODEX_BASE_URL", &upstream);+ let _transport_env = EnvGuard::set("CCP_CODEX_TRANSPORT", "http");+ let request = tokio::spawn(call_messages_body(json!({+ "model": "gpt-5.5",+ "max_tokens": 64,+ "stream": true,+ "messages": [{"role":"user","content":"hello"}]+ })));+ tokio::time::timeout(Duration::from_millis(200), async {+ while attempts.load(Ordering::SeqCst) == 0 {+ tokio::task::yield_now().await;+ }+ })+ .await+ .expect("first upstream attempt must start");+ request.abort();+ let _ = request.await;++ tokio::time::sleep(Duration::from_millis(300)).await;+ assert_eq!(attempts.load(Ordering::SeqCst), 1);+}+#[allow(clippy::await_holding_lock)]#[tokio::test]async fn smoke_codex_http_truncated_upstream_writes_reducer_diagnostic() {