Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy
Rust
fix(codex): unify live stream commit and terminal semantics (#103)
mulfyx42be3ff829a8
diff --git a/src/providers/codex/chat_completions/response.rs b/src/providers/codex/chat_completions/response.rsindex a865cdb..0afb6f8 100644--- a/src/providers/codex/chat_completions/response.rs+++ b/src/providers/codex/chat_completions/response.rs@@ -1,6 +1,8 @@+use http::StatusCode;use serde_json::{Value, json};use crate::anthropic::sse::parse_sse_events;+use crate::providers::codex::events::classify_event_failure;use super::ChatError;@@ -46,8 +48,16 @@ impl CompletionState {pub fn observe(&mut self, event: &Value) -> Result<Option<String>, ChatError> {let kind = event.get("type").and_then(Value::as_str);- if matches!(kind, Some("response.failed" | "response.error" | "error")) {- return Err(event_error(event));+ if let Some(failure) = classify_event_failure(event) {+ let status =+ StatusCode::from_u16(failure.client_status()).unwrap_or(StatusCode::BAD_GATEWAY);+ return Err(ChatError::new(+ status,+ failure.client_error_type(),+ failure.message,+ None,+ None,+ ));}match kind {Some("response.created" | "response.in_progress") => {@@ -62,7 +72,7 @@ impl CompletionState {self.text.push_str(delta);return Ok(Some(delta.to_string()));}- Some("response.completed" | "response.incomplete") => {+ Some("response.completed" | "response.done") => {let response = event.get("response").ok_or_else(|| {ChatError::upstream("Codex completion event did not contain a response")})?;@@ -70,11 +80,6 @@ impl CompletionState {if response.get("status").and_then(Value::as_str) == Some("failed") {return Err(event_error(event));}- if kind == Some("response.incomplete")- || response.get("status").and_then(Value::as_str) == Some("incomplete")- {- self.finish_reason = "length";- }self.completed = true;}_ => {@@ -199,10 +204,19 @@ mod tests {}#[test]- fn incomplete_maps_to_length() {+ fn incomplete_is_an_upstream_error() {let body = b"data: {\"type\":\"response.output_text.delta\",\"delta\":\"partial\"}\n\ndata: {\"type\":\"response.incomplete\",\"response\":{\"status\":\"incomplete\"}}\n\n";- let value = aggregate_sse(body, "model").unwrap();- assert_eq!(value["choices"][0]["finish_reason"], "length");+ let error = aggregate_sse(body, "model").unwrap_err();+ assert!(error.message.contains("Incomplete response"));+ }++ #[test]+ fn buffered_chat_preserves_typed_terminal_failure() {+ let body = b"data: {\"type\":\"response.failed\",\"response\":{\"status\":\"failed\",\"error\":{\"code\":\"context_length_exceeded\",\"message\":\"input exceeds context window\"}}}\n\n";+ let error = aggregate_sse(body, "model").unwrap_err();+ assert_eq!(error.status, StatusCode::PAYLOAD_TOO_LARGE);+ assert_eq!(error.kind, "request_too_large");+ assert_eq!(error.message, "input exceeds context window");}#[test]diff --git a/src/providers/codex/client.rs b/src/providers/codex/client.rsindex bebaeed..8f37ab8 100644--- a/src/providers/codex/client.rs+++ b/src/providers/codex/client.rs@@ -1462,6 +1462,7 @@ impl CodexHttpClient {);}+ let event_kind = super::events::classify_stream_event(&payload);let failure = super::events::classify_event_failure(&payload);if !semantic_output_forwarded&& let Some(failure) = failure.as_ref()@@ -1471,30 +1472,53 @@ impl CodexHttpClient {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;+ let terminal = super::events::event_is_terminal(&payload);+ match event_kind {+ super::events::CodexStreamEventKind::TerminalFailure => {+ if !semantic_output_forwarded {+ 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() {+ super::events::CodexStreamEventKind::TerminalSuccess => {+ for pending in pending_events.drain(..) {+ if tx.send(Ok(pending)).await.is_err() {+ return;+ }+ }+ if tx.send(Ok(payload)).await.is_err() {return;}}- if tx.send(Ok(payload)).await.is_err() {- return;+ super::events::CodexStreamEventKind::Semantic => {+ if !semantic_output_forwarded {+ 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;+ super::events::CodexStreamEventKind::Control => {+ if tx.send(Ok(payload)).await.is_err() {+ return;+ }+ }+ super::events::CodexStreamEventKind::Structural => {+ if semantic_output_forwarded {+ if tx.send(Ok(payload)).await.is_err() {+ return;+ }+ } else {+ pending_events.push(payload);+ }}- } else {- pending_events.push(payload);}if terminal {@@ -2081,6 +2105,7 @@ impl CodexHttpClient {}};+ let mut pending_events = Vec::new();loop {let item = tokio::select! {biased;@@ -2174,20 +2199,71 @@ impl CodexHttpClient {continue 'attempt;}- if item.as_ref().is_ok_and(event_closes_live_retry_window) {- forwarded_any = true;- }let terminal = item.as_ref().is_err()|| item.as_ref().is_ok_and(super::websocket::is_terminal_event);- if tx.send(item).await.is_err() {- if let Some(reservation) = continuation.as_ref() {- super::websocket::invalidate_codex_websocket_pool_socket(- reservation,- stream.socket_id(),- );+ match item {+ Ok(payload) => match super::events::classify_stream_event(&payload) {+ super::events::CodexStreamEventKind::TerminalFailure => {+ if !forwarded_any {+ pending_events.clear();+ }+ if tx.send(Ok(payload)).await.is_err() {+ return;+ }+ }+ super::events::CodexStreamEventKind::TerminalSuccess => {+ for pending in pending_events.drain(..) {+ if tx.send(Ok(pending)).await.is_err() {+ return;+ }+ }+ if tx.send(Ok(payload)).await.is_err() {+ return;+ }+ }+ super::events::CodexStreamEventKind::Semantic => {+ if !forwarded_any {+ forwarded_any = 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;+ }+ }+ super::events::CodexStreamEventKind::Control => {+ if tx.send(Ok(payload)).await.is_err() {+ return;+ }+ }+ super::events::CodexStreamEventKind::Structural => {+ if forwarded_any {+ if tx.send(Ok(payload)).await.is_err() {+ return;+ }+ } else {+ pending_events.push(payload);+ }+ }+ },+ Err(err) => {+ if tx.send(Err(err)).await.is_err() {+ if let Some(reservation) = continuation.as_ref() {+ super::websocket::invalidate_codex_websocket_pool_socket(+ reservation,+ stream.socket_id(),+ );+ }+ abort_abandoned_live_continuation(+ continuation.as_ref(),+ &socket_id_publisher,+ );+ return;+ }}- abort_abandoned_live_continuation(continuation.as_ref(), &socket_id_publisher);- return;}if terminal {return;@@ -2458,62 +2534,6 @@ fn response_headers(resp: &reqwest::Response) -> Vec<(String, 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,@@ -2953,11 +2973,9 @@ fn invalidate_live_continuation_pool(super::websocket::invalidate_codex_websocket_pool_turn_for_owner(owner, continuation.turn_id());}+#[cfg(test)]fn event_closes_live_retry_window(payload: &serde_json::Value) -> bool {- !matches!(- payload.get("type").and_then(|value| value.as_str()),- Some("codex.rate_limits" | "keepalive")- )+ super::events::classify_stream_event(payload) == super::events::CodexStreamEventKind::Semantic}pub(super) fn is_continuation_retry_error(err: &CodexError) -> bool {@@ -3432,7 +3450,7 @@ mod tests {.unwrap();write_http_chunk(&mut stream,- b"data: {\"type\":\"response.output_item.added\",\"output_index\":0,\"item\":{\"type\":\"message\",\"id\":\"msg_up\"}}\n\n",+ b"data: {\"type\":\"response.output_text.delta\",\"output_index\":0,\"delta\":\"hello\"}\n\n",).await;release_rx.await.unwrap();@@ -3462,7 +3480,7 @@ mod tests {.unwrap();assert_eq!(first_upstream.get("type").and_then(|value| value.as_str()),- Some("response.output_item.added")+ Some("response.output_text.delta"));release_tx.send(()).unwrap();@@ -5244,9 +5262,29 @@ mod tests {assert!(!event_closes_live_retry_window(&serde_json::json!({"type": "keepalive"})));- assert!(event_closes_live_retry_window(&serde_json::json!({+ assert!(!event_closes_live_retry_window(&serde_json::json!({"type": "response.created"})));+ assert!(!event_closes_live_retry_window(&serde_json::json!({+ "type": "response.output_item.added",+ "output_index": 0,+ "item": {"type": "message", "id": "msg_1"}+ })));+ assert!(!event_closes_live_retry_window(&serde_json::json!({+ "type": "response.output_item.added",+ "output_index": 0,+ "item": {"type": "function_call", "call_id": "call_1", "name": "Read"}+ })));+ assert!(event_closes_live_retry_window(&serde_json::json!({+ "type": "response.output_text.delta",+ "output_index": 0,+ "delta": "hello"+ })));+ assert!(event_closes_live_retry_window(&serde_json::json!({+ "type": "response.function_call_arguments.delta",+ "output_index": 0,+ "delta": "{}"+ })));}#[test]diff --git a/src/providers/codex/events.rs b/src/providers/codex/events.rsindex 51befdf..56b220e 100644--- a/src/providers/codex/events.rs+++ b/src/providers/codex/events.rs@@ -8,6 +8,15 @@ pub(crate) enum CodexFailureKind {Permanent,}+#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub(crate) enum CodexStreamEventKind {+ Control,+ Structural,+ Semantic,+ TerminalSuccess,+ TerminalFailure,+}+#[derive(Debug, Clone, PartialEq, Eq)]pub(crate) struct CodexEventFailure {pub kind: CodexFailureKind,@@ -21,49 +30,133 @@ impl CodexEventFailure {pub fn retryable(&self) -> bool {!matches!(self.kind, CodexFailureKind::Permanent)}++ pub fn client_status(&self) -> u16 {+ self.status+ }++ pub fn client_error_type(&self) -> &'static str {+ match self.client_status() {+ 400 | 422 => "invalid_request_error",+ 401 => "authentication_error",+ 403 => "permission_error",+ 413 => "request_too_large",+ 429 => "rate_limit_error",+ 529 => "overloaded_error",+ _ => "api_error",+ }+ }}-pub(crate) fn is_terminal_rate_limit_event(payload: &Value) -> bool {- payload.get("type").and_then(Value::as_str) == Some("codex.rate_limits")- && payload- .pointer("/rate_limits/limit_reached")- .and_then(Value::as_bool)- == Some(true)- && payload- .pointer("/credits/has_credits")- .and_then(Value::as_bool)- != Some(true)- && payload- .pointer("/credits/unlimited")- .and_then(Value::as_bool)- != Some(true)+pub(crate) fn classify_stream_event(payload: &Value) -> CodexStreamEventKind {+ if classify_event_failure(payload).is_some() {+ return CodexStreamEventKind::TerminalFailure;+ }+ match payload.get("type").and_then(Value::as_str) {+ Some("response.completed" | "response.done") => CodexStreamEventKind::TerminalSuccess,+ 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",+ ) => CodexStreamEventKind::Control,+ Some(+ "response.reasoning_summary_text.delta"+ | "response.output_text.delta"+ | "response.function_call_arguments.delta",+ ) if payload+ .get("delta")+ .and_then(Value::as_str)+ .is_some_and(|delta| !delta.is_empty()) =>+ {+ CodexStreamEventKind::Semantic+ }+ Some("response.output_item.done")+ if matches!(+ payload.pointer("/item/type").and_then(Value::as_str),+ Some("function_call" | "web_search_call")+ ) =>+ {+ CodexStreamEventKind::Semantic+ }+ _ => CodexStreamEventKind::Structural,+ }+}++pub(crate) fn event_is_terminal(payload: &Value) -> bool {+ matches!(+ classify_stream_event(payload),+ CodexStreamEventKind::TerminalSuccess | CodexStreamEventKind::TerminalFailure+ )+}++pub(crate) fn event_is_success_terminal(payload: &Value) -> bool {+ classify_stream_event(payload) == CodexStreamEventKind::TerminalSuccess}pub(crate) fn event_error(payload: &Value) -> Option<&Value> {payload.get("error")- .or_else(|| payload.pointer("/response/error"))+ .filter(|error| !error.is_null())+ .or_else(|| {+ payload+ .pointer("/response/error")+ .filter(|error| !error.is_null())+ })+}++pub(crate) fn response_is_incomplete_terminal(payload: &Value) -> bool {+ let event_type = payload.get("type").and_then(Value::as_str);+ let incomplete_details = payload.pointer("/response/incomplete_details");+ matches!(+ event_type,+ Some("response.completed" | "response.incomplete" | "response.done")+ ) && (event_type == Some("response.incomplete")+ || payload.pointer("/response/status").and_then(Value::as_str) == Some("incomplete")+ || incomplete_details.is_some_and(|details| !details.is_null()))+}++pub(crate) fn is_standard_max_output_tokens_incomplete(payload: &Value) -> bool {+ let status = payload.pointer("/response/status");+ payload.get("type").and_then(Value::as_str) == Some("response.incomplete")+ && (status.is_none() || status.and_then(Value::as_str) == Some("incomplete"))+ && payload+ .pointer("/response/incomplete_details/reason")+ .and_then(Value::as_str)+ == Some("max_output_tokens")+ && event_error(payload).is_none()}pub(crate) fn classify_event_failure(payload: &Value) -> Option<CodexEventFailure> {let event_type = payload.get("type").and_then(Value::as_str)?;+ let response_status = payload.pointer("/response/status").and_then(Value::as_str);if event_type == "codex.rate_limits" {- if !is_terminal_rate_limit_event(payload) {- return None;- }+ return None;+ }+ if response_is_incomplete_terminal(payload) {+ let reason = payload+ .pointer("/response/incomplete_details/reason")+ .and_then(Value::as_str)+ .unwrap_or("unknown");return Some(CodexEventFailure {- kind: CodexFailureKind::RateLimit,- explicit_status: Some(429),- status: 429,- message: "rate limit reached".to_string(),- retry_after: scalar_string(payload.pointer("/rate_limits/primary/reset_after_seconds")),+ kind: CodexFailureKind::Transient,+ explicit_status: None,+ status: 503,+ message: format!("Incomplete response returned, reason: {reason}"),+ retry_after: None,});}- if !matches!(event_type, "response.failed" | "response.error" | "error") {+ let error = event_error(payload);+ if !matches!(event_type, "response.failed" | "response.error" | "error")+ && response_status != Some("failed")+ && error.is_none()+ {return None;}- let error = event_error(payload);let explicit_status = numeric_status(payload).or_else(|| {error@@ -71,20 +164,47 @@ pub(crate) fn classify_event_failure(payload: &Value) -> Option<CodexEventFailur.and_then(Value::as_u64)}).and_then(|status| u16::try_from(status).ok());- let message = error- .and_then(|value| value.get("message"))- .and_then(Value::as_str)- .unwrap_or("Upstream error")- .to_string();let code = error.and_then(|value| value.get("code")).and_then(Value::as_str);let error_type = error.and_then(|value| value.get("type")).and_then(Value::as_str);+ let raw_message = error+ .and_then(|value| value.get("message"))+ .and_then(Value::as_str);+ let message = match (code, raw_message) {+ (Some("cyber_policy"), None | Some("")) => {+ "This request has been flagged for possible cybersecurity risk.".to_string()+ }+ (Some("cyber_policy"), Some(message)) if message.trim().is_empty() => {+ "This request has been flagged for possible cybersecurity risk.".to_string()+ }+ (Some("invalid_prompt" | "bio_policy"), None) => "Invalid request.".to_string(),+ (_, Some(message)) => message.to_string(),+ _ => "Upstream error".to_string(),+ };let lower = message.to_ascii_lowercase();+ let context_window = code == Some("context_length_exceeded")+ || lower.contains("context window")+ || lower.contains("context length exceeded");- let kind = if explicit_status == Some(429) || lower.contains("rate limit") {+ let kind = if context_window+ || matches!(+ code,+ Some(+ "context_length_exceeded"+ | "insufficient_quota"+ | "usage_not_included"+ | "cyber_policy"+ | "invalid_prompt"+ | "bio_policy"+ )+ ) {+ CodexFailureKind::Permanent+ } else if matches!(code, Some("server_is_overloaded" | "slow_down")) {+ CodexFailureKind::Overloaded+ } else if explicit_status == Some(429) || lower.contains("rate limit") {CodexFailureKind::RateLimit} else if explicit_status == Some(529)|| code == Some("overloaded_error")@@ -104,15 +224,28 @@ pub(crate) fn classify_event_failure(payload: &Value) -> Option<CodexEventFailur|| retryable_message(&lower){CodexFailureKind::Transient- } else {+ } else if explicit_status.is_some() || matches!(event_type, "response.error" | "error") {CodexFailureKind::Permanent+ } else {+ // Native Codex treats an unclassified response.failed event as+ // retryable instead of silently converting it into a successful turn.+ CodexFailureKind::Transient+ };+ let status = if context_window {+ 413+ } else {+ explicit_status.unwrap_or(match code {+ Some("cyber_policy" | "invalid_prompt" | "bio_policy") => 400,+ Some("insufficient_quota") => 429,+ Some("usage_not_included") => 403,+ _ => match kind {+ CodexFailureKind::RateLimit => 429,+ CodexFailureKind::Overloaded => 529,+ CodexFailureKind::Transient => 503,+ CodexFailureKind::Permanent => 500,+ },+ })};- let status = explicit_status.unwrap_or(match kind {- CodexFailureKind::RateLimit => 429,- CodexFailureKind::Overloaded => 529,- CodexFailureKind::Transient => 503,- CodexFailureKind::Permanent => 500,- });let retry_after = error.and_then(|value| value.get("retry_after")).and_then(scalar_string_value)@@ -135,6 +268,10 @@ pub(crate) fn classify_event_failure(payload: &Value) -> Option<CodexEventFailur}pub(crate) fn first_retryable_failure(body: &[u8]) -> Option<CodexEventFailure> {+ first_event_failure(body).filter(CodexEventFailure::retryable)+}++pub(crate) fn first_event_failure(body: &[u8]) -> Option<CodexEventFailure> {for event in crate::anthropic::sse::parse_sse_events(body) {if event.data == "[DONE]" {continue;@@ -142,9 +279,7 @@ pub(crate) fn first_retryable_failure(body: &[u8]) -> Option<CodexEventFailure>let Ok(payload) = serde_json::from_str::<Value>(&event.data) else {continue;};- if let Some(failure) = classify_event_failure(&payload)- && failure.retryable()- {+ if let Some(failure) = classify_event_failure(&payload) {return Some(failure);}}@@ -203,14 +338,6 @@ mod tests {#[test]fn classifies_retryable_failure_kinds() {- let rate = classify_event_failure(&serde_json::json!({- "type": "codex.rate_limits",- "rate_limits": {"limit_reached": true, "primary": {"reset_after_seconds": 1.5}}- }))- .unwrap();- assert_eq!(rate.kind, CodexFailureKind::RateLimit);- assert_eq!(rate.retry_after.as_deref(), Some("1.5"));-let overload = classify_event_failure(&serde_json::json!({"type": "response.failed","response": {"error": {"type": "overloaded_error", "message": "busy"}}@@ -221,55 +348,12 @@ mod tests {}#[test]- fn terminal_rate_limit_honors_credits() {- // No credits field at all: legacy payload stays terminal.- assert!(is_terminal_rate_limit_event(&serde_json::json!({- "type": "codex.rate_limits",- "rate_limits": {"limit_reached": true}- })));-- // Credits exhausted: terminal.- assert!(is_terminal_rate_limit_event(&serde_json::json!({- "type": "codex.rate_limits",- "rate_limits": {"limit_reached": true},- "credits": {"has_credits": false, "unlimited": false}- })));-- // Usable credits remain: informational.- assert!(!is_terminal_rate_limit_event(&serde_json::json!({- "type": "codex.rate_limits",- "rate_limits": {"limit_reached": true},- "credits": {"has_credits": true, "unlimited": false}- })));-- // Unlimited plan: informational.- assert!(!is_terminal_rate_limit_event(&serde_json::json!({- "type": "codex.rate_limits",- "rate_limits": {"limit_reached": true},- "credits": {"has_credits": false, "unlimited": true}- })));-- // Limit not reached: never terminal, credits irrelevant.- assert!(!is_terminal_rate_limit_event(&serde_json::json!({- "type": "codex.rate_limits",- "rate_limits": {"limit_reached": false},- "credits": {"has_credits": false, "unlimited": false}- })));-- // Wrong event type never matches.- assert!(!is_terminal_rate_limit_event(&serde_json::json!({- "type": "response.completed",- "rate_limits": {"limit_reached": true}- })));- }-- #[test]- fn classifier_skips_credited_rate_limit_snapshots() {+ fn rate_limit_snapshots_are_always_telemetry() {assert!(classify_event_failure(&serde_json::json!({"type": "codex.rate_limits","rate_limits": {"limit_reached": true},- "credits": {"has_credits": true, "unlimited": false}+ "credits": {"has_credits": false, "unlimited": false}})).is_none());@@ -291,4 +375,198 @@ mod tests {.unwrap();assert!(!failure.retryable());}++ #[test]+ fn classifies_progress_and_terminal_semantics() {+ assert_eq!(+ classify_stream_event(&serde_json::json!({"type":"response.created"})),+ CodexStreamEventKind::Control+ );+ assert_eq!(+ classify_stream_event(&serde_json::json!({+ "type":"response.output_item.added",+ "item":{"type":"function_call"}+ })),+ CodexStreamEventKind::Structural+ );+ assert_eq!(+ classify_stream_event(&serde_json::json!({+ "type":"response.function_call_arguments.delta",+ "delta":"{}"+ })),+ CodexStreamEventKind::Semantic+ );+ assert_eq!(+ classify_stream_event(&serde_json::json!({"type":"response.incomplete"})),+ CodexStreamEventKind::TerminalFailure+ );+ assert_eq!(+ classify_stream_event(&serde_json::json!({+ "type":"response.completed",+ "error": null,+ "response": {+ "status":"failed",+ "error":{"status":400,"code":"invalid_prompt","message":"rejected"}+ }+ })),+ CodexStreamEventKind::TerminalFailure+ );+ }++ #[test]+ fn nested_response_error_survives_null_top_level_error() {+ let failure = classify_event_failure(&serde_json::json!({+ "type":"response.completed",+ "error": null,+ "response": {+ "status":"failed",+ "error":{"status":400,"code":"invalid_prompt","message":"nested rejection"}+ }+ }))+ .unwrap();+ assert_eq!(failure.client_status(), 400);+ assert_eq!(failure.client_error_type(), "invalid_request_error");+ assert_eq!(failure.message, "nested rejection");+ assert!(!failure.retryable());+ }++ #[test]+ fn completed_event_with_nested_error_is_not_success() {+ let payload = serde_json::json!({+ "type":"response.completed",+ "error": null,+ "response": {+ "status":"completed",+ "error":{"status":502,"code":"server_error","message":"late failure"}+ }+ });+ let failure = classify_event_failure(&payload).unwrap();+ assert_eq!(failure.client_status(), 502);+ assert!(failure.retryable());+ assert_eq!(+ classify_stream_event(&payload),+ CodexStreamEventKind::TerminalFailure+ );+ }++ #[test]+ fn completed_event_with_nested_null_error_is_success() {+ let payload = serde_json::json!({+ "type":"response.completed",+ "error": null,+ "response": {"status":"completed", "error":null}+ });+ assert!(classify_event_failure(&payload).is_none());+ assert_eq!(+ classify_stream_event(&payload),+ CodexStreamEventKind::TerminalSuccess+ );+ }++ #[test]+ fn native_fatal_codes_are_not_retried_without_numeric_status() {+ for (code, status, error_type) in [+ ("context_length_exceeded", 413, "request_too_large"),+ ("cyber_policy", 400, "invalid_request_error"),+ ("invalid_prompt", 400, "invalid_request_error"),+ ("bio_policy", 400, "invalid_request_error"),+ ("insufficient_quota", 429, "rate_limit_error"),+ ("usage_not_included", 403, "permission_error"),+ ] {+ let failure = classify_event_failure(&serde_json::json!({+ "type":"response.failed",+ "response":{"status":"failed","error":{"code":code,"message":"rejected"}}+ }))+ .unwrap();+ assert!(!failure.retryable(), "{code}");+ assert_eq!(failure.client_status(), status, "{code}");+ assert_eq!(failure.client_error_type(), error_type, "{code}");+ }+ }++ #[test]+ fn native_overload_codes_remain_retryable_without_numeric_status() {+ for code in ["server_is_overloaded", "slow_down"] {+ let failure = classify_event_failure(&serde_json::json!({+ "type":"response.failed",+ "response":{"status":"failed","error":{"code":code,"message":"busy"}}+ }))+ .unwrap();+ assert!(failure.retryable(), "{code}");+ assert_eq!(failure.client_status(), 529, "{code}");+ assert_eq!(failure.client_error_type(), "overloaded_error", "{code}");+ }+ }++ #[test]+ fn context_window_message_overrides_generic_upstream_400() {+ let failure = classify_event_failure(&serde_json::json!({+ "type":"error",+ "status":400,+ "error":{"type":"invalid_request_error","message":"input exceeds context window"}+ }))+ .unwrap();+ assert!(!failure.retryable());+ assert_eq!(failure.explicit_status, Some(400));+ assert_eq!(failure.client_status(), 413);+ assert_eq!(failure.client_error_type(), "request_too_large");+ }++ #[test]+ fn incomplete_policy_only_accepts_consistent_max_output_terminal() {+ let allowed = serde_json::json!({+ "type":"response.incomplete",+ "response": {+ "status":"incomplete",+ "error":null,+ "incomplete_details":{"reason":"max_output_tokens"}+ }+ });+ assert!(response_is_incomplete_terminal(&allowed));+ assert!(is_standard_max_output_tokens_incomplete(&allowed));+ let allowed_without_status = serde_json::json!({+ "type":"response.incomplete",+ "response": {+ "incomplete_details":{"reason":"max_output_tokens"}+ }+ });+ assert!(is_standard_max_output_tokens_incomplete(+ &allowed_without_status+ ));++ for rejected in [+ serde_json::json!({+ "type":"response.incomplete",+ "response":{"status":"incomplete","incomplete_details":{"reason":"content_filter"}}+ }),+ serde_json::json!({+ "type":"response.incomplete",+ "response":{"status":"incomplete","incomplete_details":{}}+ }),+ serde_json::json!({+ "type":"response.completed",+ "response":{"status":"completed","incomplete_details":{"reason":"max_output_tokens"}}+ }),+ serde_json::json!({+ "type":"response.incomplete",+ "response":{"status":null,"incomplete_details":{"reason":"max_output_tokens"}}+ }),+ serde_json::json!({+ "type":"response.incomplete",+ "response":{"status":123,"incomplete_details":{"reason":"max_output_tokens"}}+ }),+ serde_json::json!({+ "type":"response.incomplete",+ "response":{"status":"completed","incomplete_details":{"reason":"max_output_tokens"}}+ }),+ serde_json::json!({+ "type":"response.completed",+ "response":{"status":"completed","incomplete_details":{}}+ }),+ ] {+ assert!(response_is_incomplete_terminal(&rejected));+ assert!(!is_standard_max_output_tokens_incomplete(&rejected));+ assert!(classify_event_failure(&rejected).is_some());+ }+ }}diff --git a/src/providers/codex/mod.rs b/src/providers/codex/mod.rsindex 54aaad7..c09f930 100644--- a/src/providers/codex/mod.rs+++ b/src/providers/codex/mod.rs@@ -407,6 +407,11 @@ impl CodexProvider {attempt += 1;sleep(delay.wait_ms).await;};+ if let Some(failure) = events::first_event_failure(&upstream.body) {+ abort_compaction_attempt(ctx.session_id.as_deref(), compaction_attempt);+ abort_continuation_for_owner(&request_continuation);+ return map_codex_event_failure_to_response(&failure);+ }log.info("codex_upstream_response_received",Some(serde_json::Map::from_iter([@@ -885,39 +890,24 @@ async fn live_stream_response_once({Ok(result) => result,Err(message) => {- if retryable_live_start_payload(&payload, &message) {- let lower_message = message.to_ascii_lowercase();- let status = websocket::event_error_status(&payload).unwrap_or_else(|| {- let error = payload.get("error").or_else(|| {- payload.get("response").and_then(|value| value.get("error"))- });- let overloaded = error.is_some_and(|error| {- error.get("code").and_then(|value| value.as_str())- == Some("overloaded_error")- || error.get("type").and_then(|value| value.as_str())- == Some("overloaded_error")- });- if payload.get("type").and_then(|value| value.as_str())- == Some("codex.rate_limits")- || lower_message.contains("rate limit")- {- 429- } else if overloaded || lower_message.contains("overloaded") {- 529- } else {- 503- }- });- return provider_retry(- &upstream_events,- client::CodexError {- status,- message: message.clone(),- detail: Some(message),- retry_after: retry_after_from_live_payload(&payload),- origin: client::CodexErrorOrigin::WebSocket,- },+ if let Some(failure) = events::classify_event_failure(&payload) {+ if failure.retryable() {+ return provider_retry(+ &upstream_events,+ codex_event_failure_error(+ &failure,+ client::CodexErrorOrigin::WebSocket,+ ),+ );+ }+ abort_request_state(+ ctx.session_id.as_deref(),+ &request_continuation,+ compaction.attempt,);+ return LiveStreamStart::Response(map_codex_event_failure_to_response(+ &failure,+ ));}abort_request_state(ctx.session_id.as_deref(),@@ -1014,7 +1004,7 @@ fn translate_live_stream_payload(traffic: Option<&crate::traffic::TrafficCapture>,) -> Result<(Vec<u8>, bool), String> {let chunk = translator.accept(payload, traffic)?;- let terminal = is_codex_terminal_event(payload) || translator.is_finished();+ let terminal = events::event_is_terminal(payload) || translator.is_finished();Ok((chunk, terminal))}@@ -1129,9 +1119,16 @@ fn remaining_live_stream_response(&request_continuation,compaction.attempt,);+ let failure = events::classify_event_failure(&payload);+ let error_type = failure+ .as_ref()+ .map_or("api_error", events::CodexEventFailure::client_error_type);+ let error_message = failure+ .as_ref()+ .map_or(message.as_str(), |failure| failure.message.as_str());let chunk = translator.error_chunk(- &message,- "api_error",+ error_message,+ error_type,ctx.traffic.as_deref(),);if !chunk.is_empty() {@@ -1171,12 +1168,14 @@ fn remaining_live_stream_response(&request_continuation,compaction.attempt,);- let chunk =- translator.finish_after_closed_completed_tool_call(ctx.traffic.as_deref());- if !chunk.is_empty() {- record_live_stream_progress(&ctx, &chunk);- let _ = tx.send(Ok(Bytes::from(chunk))).await;- return;+ if err.origin == client::CodexErrorOrigin::WebSocket {+ let chunk = translator+ .finish_after_closed_completed_tool_call(ctx.traffic.as_deref());+ if !chunk.is_empty() {+ record_live_stream_progress(&ctx, &chunk);+ let _ = tx.send(Ok(Bytes::from(chunk))).await;+ return;+ }}let error_type = codex_stream_error_type(&err);let chunk = translator.error_chunk(@@ -1282,23 +1281,8 @@ fn is_empty_codex_success_completion(upstream_sse: &[u8]) -> bool {saw_success_terminal}-fn is_codex_terminal_event(payload: &serde_json::Value) -> bool {- matches!(- payload.get("type").and_then(|v| v.as_str()),- Some("response.completed")- | Some("response.incomplete")- | Some("response.done")- | Some("response.failed")- | Some("response.error")- | Some("error")- )-}-fn is_codex_success_terminal_event(payload: &serde_json::Value) -> bool {- matches!(- payload.get("type").and_then(|v| v.as_str()),- Some("response.completed") | Some("response.done")- )+ events::event_is_success_terminal(payload)}fn retryable_live_start_codex_error(err: &client::CodexError) -> bool {@@ -1355,12 +1339,17 @@ fn retryable_live_message(message: &str) -> bool {.any(|needle| lower.contains(needle))}-fn retryable_live_start_payload(payload: &serde_json::Value, _message: &str) -> bool {- events::classify_event_failure(payload).is_some_and(|failure| failure.retryable())-}--fn retry_after_from_live_payload(payload: &serde_json::Value) -> Option<String> {- events::classify_event_failure(payload).and_then(|failure| failure.retry_after)+fn codex_event_failure_error(+ failure: &events::CodexEventFailure,+ origin: client::CodexErrorOrigin,+) -> client::CodexError {+ client::CodexError {+ status: failure.status,+ message: failure.message.clone(),+ detail: Some(failure.message.clone()),+ retry_after: failure.retry_after.clone(),+ origin,+ }}fn codex_stream_error_type(err: &client::CodexError) -> &'static str {@@ -1480,6 +1469,16 @@ fn map_codex_failure_to_response(message: &str) -> Response {}}+fn map_codex_event_failure_to_response(failure: &events::CodexEventFailure) -> Response {+ let status = StatusCode::from_u16(failure.client_status()).unwrap_or(StatusCode::BAD_GATEWAY);+ let response = json_error(status, failure.client_error_type(), &failure.message);+ if let Some(retry_after) = failure.retry_after.as_deref() {+ ([(http::header::RETRY_AFTER, retry_after)], response).into_response()+ } else {+ response+ }+}+fn is_context_window_overflow(message: &str) -> bool {message.to_ascii_lowercase().contains("context window")}@@ -2129,28 +2128,28 @@ mod tests {}#[test]- fn live_start_payload_retry_detection_covers_rate_limit_and_overload() {- assert!(retryable_live_start_payload(- &serde_json::json!({+ fn live_start_payload_retry_detection_uses_event_failure_classification() {+ assert!(+ events::classify_event_failure(&serde_json::json!({"type": "codex.rate_limits","rate_limits": {"limit_reached": true}- }),- "rate limit reached",- ));- assert!(retryable_live_start_payload(- &serde_json::json!({+ }))+ .is_none()+ );+ assert!(+ events::classify_event_failure(&serde_json::json!({"type": "response.failed","response": {"error": {"type": "overloaded_error", "message": "overloaded"}}- }),- "overloaded",- ));- assert!(!retryable_live_start_payload(- &serde_json::json!({+ }))+ .is_some_and(|failure| failure.retryable())+ );+ assert!(+ !events::classify_event_failure(&serde_json::json!({"type": "response.failed",- "response": {"error": {"message": "bad request"}}- }),- "bad request",- ));+ "response": {"error": {"status": 400, "code": "invalid_prompt", "message": "bad request"}}+ }))+ .is_some_and(|failure| failure.retryable())+ );}async fn run_live_failure_case(@@ -2405,11 +2404,15 @@ mod tests {let status = run_live_failure_case("live-retry-exhaustion-cleanup",serde_json::json!({- "type": "codex.rate_limits",- "rate_limits": {- "allowed": false,- "limit_reached": true,- "primary": {"reset_after_seconds": 0}+ "type": "response.failed",+ "response": {+ "status": "failed",+ "error": {+ "status": 429,+ "code": "rate_limit_exceeded",+ "message": "rate limit reached",+ "retry_after_seconds": 0+ }}}),11,@@ -2425,11 +2428,15 @@ mod tests {let status = run_live_failure_case("live-excessive-retry-after-cleanup",serde_json::json!({- "type": "codex.rate_limits",- "rate_limits": {- "allowed": false,- "limit_reached": true,- "primary": {"reset_after_seconds": 31}+ "type": "response.failed",+ "response": {+ "status": "failed",+ "error": {+ "status": 429,+ "code": "rate_limit_exceeded",+ "message": "rate limit reached",+ "retry_after_seconds": 31+ }}}),1,@@ -2448,13 +2455,17 @@ mod tests {"type": "response.failed","response": {"status": "failed",- "error": {"message": "invalid request"}+ "error": {+ "status": 400,+ "code": "invalid_prompt",+ "message": "invalid request"+ }}}),1,).await;- assert_eq!(status, StatusCode::BAD_GATEWAY);+ assert_eq!(status, StatusCode::BAD_REQUEST);}#[tokio::test]diff --git a/src/providers/codex/translate/accumulate.rs b/src/providers/codex/translate/accumulate.rsindex f7c3f34..7157460 100644--- a/src/providers/codex/translate/accumulate.rs+++ b/src/providers/codex/translate/accumulate.rs@@ -2,9 +2,10 @@ use serde_json::Value;use crate::traffic::TrafficCapture;+use super::IncompleteResponsePolicy;use super::reducer::{AnthropicUsage, ReducerEvent, UpstreamStreamError, map_codex_usage_to_anthropic,- reduce_upstream_bytes,+ reduce_upstream_bytes_with_policy,};use super::web_search_compat::{WebSearchCompatContent, build_web_search_compat_blocks};@@ -13,7 +14,13 @@ pub fn accumulate_response(message_id: &str,model: &str,) -> Result<Value, anyhow::Error> {- accumulate_response_with_traffic(upstream, message_id, model, None)+ accumulate_response_with_policy_and_traffic(+ upstream,+ message_id,+ model,+ IncompleteResponsePolicy::Error,+ None,+ )}pub fn accumulate_response_with_traffic(@@ -22,7 +29,38 @@ pub fn accumulate_response_with_traffic(model: &str,traffic: Option<&TrafficCapture>,) -> Result<Value, anyhow::Error> {- let events = match reduce_upstream_bytes(upstream) {+ accumulate_response_with_policy_and_traffic(+ upstream,+ message_id,+ model,+ IncompleteResponsePolicy::Error,+ traffic,+ )+}++pub(crate) fn accumulate_response_with_policy(+ upstream: &[u8],+ message_id: &str,+ model: &str,+ incomplete_response_policy: IncompleteResponsePolicy,+) -> Result<Value, anyhow::Error> {+ accumulate_response_with_policy_and_traffic(+ upstream,+ message_id,+ model,+ incomplete_response_policy,+ None,+ )+}++fn accumulate_response_with_policy_and_traffic(+ upstream: &[u8],+ message_id: &str,+ model: &str,+ incomplete_response_policy: IncompleteResponsePolicy,+ traffic: Option<&TrafficCapture>,+) -> Result<Value, anyhow::Error> {+ let events = match reduce_upstream_bytes_with_policy(upstream, incomplete_response_policy) {Ok(events) => events,Err(err) => {write_reducer_error_capture(traffic, &err);diff --git a/src/providers/codex/translate/live_stream.rs b/src/providers/codex/translate/live_stream.rsindex 8a20163..d8e868f 100644--- a/src/providers/codex/translate/live_stream.rs+++ b/src/providers/codex/translate/live_stream.rs@@ -1,9 +1,12 @@use std::collections::HashMap;use crate::anthropic::sse::encode_sse_event;-use crate::providers::codex::events::is_terminal_rate_limit_event;+use crate::providers::codex::events::{+ classify_event_failure, is_standard_max_output_tokens_incomplete,+};use crate::traffic::TrafficCapture;+use super::IncompleteResponsePolicy;use super::read_rewrite::sanitize_read_args;use super::reasoning_signature::{PendingReasoning, encode_reasoning_signature};use super::reducer::{@@ -67,6 +70,7 @@ pub struct LiveStreamTranslator {// Seeds Claude Code's live subagent counter until the provider returns// authoritative usage in the terminal message_delta.estimated_input_tokens: u64,+ incomplete_response_policy: IncompleteResponsePolicy,finished: bool,}@@ -96,10 +100,19 @@ impl LiveStreamTranslator {deferred_text: Vec::new(),semantic_output_started: false,estimated_input_tokens,+ incomplete_response_policy: IncompleteResponsePolicy::Error,finished: false,}}+ pub(crate) fn with_incomplete_response_policy(+ mut self,+ policy: IncompleteResponsePolicy,+ ) -> Self {+ self.incomplete_response_policy = policy;+ self+ }+pub fn accept(&mut self,payload: &serde_json::Value,@@ -112,19 +125,20 @@ impl LiveStreamTranslator {let kind = payload.get("type").and_then(|v| v.as_str()).unwrap_or("");let mut out = Vec::new();+ let allowed_incomplete = self.incomplete_response_policy+ == IncompleteResponsePolicy::AllowMaxOutputTokens+ && is_standard_max_output_tokens_incomplete(payload);+ if !allowed_incomplete && let Some(failure) = classify_event_failure(payload) {+ return Err(failure.message);+ }+match kind {"codex.rate_limits" => {- 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);}- "response.failed" | "response.error" | "error" => {- return Err(error_message(payload));- }"response.web_search_call.in_progress"| "response.web_search_call.searching"| "response.web_search_call.completed" => {}@@ -339,7 +353,6 @@ impl LiveStreamTranslator {"function_call" => {self.close_thinking(traffic, out);self.saw_tool_use = true;- self.semantic_output_started = true;let index = self.anthropic_index;self.anthropic_index += 1;let call_id = item@@ -530,6 +543,7 @@ impl LiveStreamTranslator {if delta.is_empty() {return Ok(());}+ self.semantic_output_started = true;let mut repaired_read: Option<(usize, String)> = None;let Some(LiveBlock::Tool {index,@@ -562,6 +576,7 @@ impl LiveStreamTranslator {} else {*emitted_args = true;let index = *index;+ self.semantic_output_started = true;self.emit(traffic,out,@@ -579,6 +594,7 @@ impl LiveStreamTranslator {}if let Some((index, repaired)) = repaired_read {self.blocks_by_output_index.remove(&output_index);+ self.semantic_output_started = true;self.emit(traffic,out,@@ -713,6 +729,7 @@ impl LiveStreamTranslator {emitted_args,..} => {+ self.semantic_output_started = true;if let Some(final_args) = payload.get("item").and_then(|item| item.get("arguments"))@@ -896,8 +913,10 @@ impl LiveStreamTranslator {self.emit_web_searches(traffic, out);self.ensure_message_start(traffic, out);let usage = payload.get("response").map(parse_codex_usage);- let incomplete = response_is_incomplete(payload);- let stop_reason = if incomplete {+ let stop_reason = if self.incomplete_response_policy+ == IncompleteResponsePolicy::AllowMaxOutputTokens+ && is_standard_max_output_tokens_incomplete(payload)+ {STOP_MAX_TOKENS} else if self.saw_tool_use {STOP_TOOL_USE@@ -1095,21 +1114,6 @@ fn parse_codex_usage(response: &serde_json::Value) -> CodexUsage {}}-fn response_is_incomplete(payload: &serde_json::Value) -> bool {- payload.get("type").and_then(|v| v.as_str()) == Some("response.incomplete")- || payload- .get("response")- .and_then(|r| r.get("status"))- .and_then(|v| v.as_str())- == Some("incomplete")- || payload- .get("response")- .and_then(|r| r.get("incomplete_details"))- .and_then(|d| d.get("reason"))- .and_then(|v| v.as_str())- .is_some()-}-fn repair_whitespace_stalled_read_args(name: &str,args: &str,@@ -1178,22 +1182,6 @@ fn is_valid_read_args(value: &serde_json::Value) -> bool {true}-fn error_message(payload: &serde_json::Value) -> String {- payload- .get("response")- .and_then(|r| r.get("error"))- .and_then(|e| e.get("message"))- .and_then(|v| v.as_str())- .or_else(|| {- payload- .get("error")- .and_then(|e| e.get("message"))- .and_then(|v| v.as_str())- })- .unwrap_or("Upstream error")- .to_string()-}-#[cfg(test)]mod tests {use super::*;@@ -1330,7 +1318,73 @@ mod tests {}#[test]- fn tool_thinking_and_web_search_events_are_semantic() {+ fn strict_live_translator_rejects_incomplete_response() {+ let mut translator = LiveStreamTranslator::new("msg_1", "gpt-5.5");+ let error = translator+ .accept(+ &json!({+ "type":"response.incomplete",+ "response": {+ "status":"incomplete",+ "incomplete_details":{"reason":"max_output_tokens"}+ }+ }),+ None,+ )+ .unwrap_err();+ assert!(error.contains("max_output_tokens"));+ }++ #[test]+ fn standard_responses_policy_maps_max_output_tokens_to_message_stop() {+ let mut translator = LiveStreamTranslator::new("msg_1", "gpt-5.6-luna")+ .with_incomplete_response_policy(IncompleteResponsePolicy::AllowMaxOutputTokens);+ let out = translator+ .accept(+ &json!({+ "type":"response.incomplete",+ "response": {+ "status":"incomplete",+ "error":null,+ "incomplete_details":{"reason":"max_output_tokens"},+ "usage":{"input_tokens":2,"output_tokens":8}+ }+ }),+ None,+ )+ .unwrap();+ let out = String::from_utf8(out).unwrap();+ assert!(out.contains(r#""stop_reason":"max_tokens""#));+ assert!(out.contains(r#""output_tokens":8"#));+ assert!(out.contains("event: message_stop"));+ assert!(translator.is_finished());+ }++ #[test]+ fn standard_responses_policy_rejects_other_incomplete_reasons() {+ for reason in ["content_filter", "unknown"] {+ let mut translator = LiveStreamTranslator::new("msg_1", "gpt-5.6-luna")+ .with_incomplete_response_policy(IncompleteResponsePolicy::AllowMaxOutputTokens);+ assert!(+ translator+ .accept(+ &json!({+ "type":"response.incomplete",+ "response": {+ "status":"incomplete",+ "incomplete_details":{"reason":reason}+ }+ }),+ None,+ )+ .is_err(),+ "{reason}"+ );+ }+ }++ #[test]+ fn structural_tool_start_is_not_semantic_until_arguments_arrive() {let mut tool = LiveStreamTranslator::new("msg_tool", "gpt-5.5");tool.accept(&json!({@@ -1341,6 +1395,16 @@ mod tests {None,).unwrap();+ assert!(!tool.has_semantic_output());+ tool.accept(+ &json!({+ "type": "response.function_call_arguments.delta",+ "output_index": 0,+ "delta": "{}"+ }),+ None,+ )+ .unwrap();assert!(tool.has_semantic_output());let mut thinking = LiveStreamTranslator::new("msg_thinking", "gpt-5.5");@@ -1455,7 +1519,7 @@ mod tests {}#[test]- fn finishes_after_closed_completed_tool_call() {+ fn websocket_compat_can_finish_after_closed_completed_tool_call() {let mut translator = LiveStreamTranslator::new("msg_1", "gpt-5.5");let mut out = Vec::new();for event in [@@ -1546,9 +1610,9 @@ mod tests {}#[test]- fn rate_limit_event_returns_error() {+ fn rate_limit_event_is_progress_telemetry() {let mut translator = LiveStreamTranslator::new("msg_1", "gpt-5.5");- let err = translator+ let out = translator.accept(&json!({"type": "codex.rate_limits",@@ -1556,8 +1620,10 @@ mod tests {}),None,)- .unwrap_err();- assert_eq!(err, "rate limit reached");+ .unwrap();+ let out = String::from_utf8(out).unwrap();+ assert!(out.contains("event: ping"));+ assert!(!out.contains("event: error"));}#[test]diff --git a/src/providers/codex/translate/mod.rs b/src/providers/codex/translate/mod.rsindex cdf6f42..08ec349 100644--- a/src/providers/codex/translate/mod.rs+++ b/src/providers/codex/translate/mod.rs@@ -7,3 +7,9 @@ pub mod reducer;pub mod request;pub mod stream;pub mod web_search_compat;++#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub(crate) enum IncompleteResponsePolicy {+ Error,+ AllowMaxOutputTokens,+}diff --git a/src/providers/codex/translate/reducer.rs b/src/providers/codex/translate/reducer.rsindex 83beec6..b79102b 100644--- a/src/providers/codex/translate/reducer.rs+++ b/src/providers/codex/translate/reducer.rs@@ -1,6 +1,10 @@use crate::anthropic::sse::parse_sse_events;-use crate::providers::codex::events::is_terminal_rate_limit_event;+use crate::providers::codex::events::{+ CodexFailureKind, classify_event_failure, is_standard_max_output_tokens_incomplete,+ response_is_incomplete_terminal,+};+use super::IncompleteResponsePolicy;use super::read_rewrite::sanitize_read_args;use super::reasoning_signature::{PendingReasoning, ReasoningReplay, encode_reasoning_signature};use super::request::ResponsesInputItem;@@ -245,6 +249,13 @@ pub fn finish_metadata_from_upstream(}pub fn reduce_upstream_bytes(input: &[u8]) -> Result<Vec<ReducerEvent>, UpstreamStreamError> {+ reduce_upstream_bytes_with_policy(input, IncompleteResponsePolicy::Error)+}++pub(crate) fn reduce_upstream_bytes_with_policy(+ input: &[u8],+ incomplete_response_policy: IncompleteResponsePolicy,+) -> Result<Vec<ReducerEvent>, UpstreamStreamError> {let sse_events = parse_sse_events(input);let mut out = Vec::new();@@ -329,20 +340,53 @@ pub fn reduce_upstream_bytes(input: &[u8]) -> Result<Vec<ReducerEvent>, Upstreamevent_count += 1;last_event_type = Some(t.clone());+ if _saw_terminal {+ let message = if t == "response.completed"+ || t == "response.incomplete"+ || t == "response.done"+ {+ "upstream stream contained multiple terminal Codex response events"+ } else {+ "upstream stream contained a JSON event after the terminal Codex response event"+ };+ return Err(UpstreamStreamError {+ kind: UpstreamErrorKind::Transient,+ message: message.to_string(),+ retry_after_seconds: None,+ diagnostics: Some(UpstreamStreamDiagnostics {+ event_count,+ last_event_type,+ saw_terminal_event: true,+ open_blocks: describe_open_blocks(&blocks_by_output_index),+ }),+ });+ }++ let allowed_incomplete = incomplete_response_policy+ == IncompleteResponsePolicy::AllowMaxOutputTokens+ && is_standard_max_output_tokens_incomplete(&p);+ if !allowed_incomplete && let Some(failure) = classify_event_failure(&p) {+ let kind = match failure.kind {+ CodexFailureKind::RateLimit => UpstreamErrorKind::RateLimit,+ CodexFailureKind::Overloaded => UpstreamErrorKind::Overloaded,+ CodexFailureKind::Transient => UpstreamErrorKind::Transient,+ CodexFailureKind::Permanent => UpstreamErrorKind::Failed,+ };+ let retry_after_seconds = failure+ .retry_after+ .as_deref()+ .and_then(|value| value.parse::<f64>().ok())+ .filter(|value| value.is_finite() && *value >= 0.0)+ .map(|value| value.ceil() as u64);+ return Err(UpstreamStreamError {+ kind,+ message: failure.message,+ retry_after_seconds,+ diagnostics: None,+ });+ }+if t == "codex.rate_limits" {- if is_terminal_rate_limit_event(&p) {- let retry_after = p- .get("rate_limits")- .and_then(|r| r.get("primary"))- .and_then(|r| r.get("reset_after_seconds"))- .and_then(|v| v.as_f64());- return Err(UpstreamStreamError {- kind: UpstreamErrorKind::RateLimit,- message: "rate limit reached".to_string(),- retry_after_seconds: retry_after.map(|f| f as u64),- diagnostics: None,- });- }out.push(ReducerEvent::Progress);continue;}@@ -360,28 +404,6 @@ pub fn reduce_upstream_bytes(input: &[u8]) -> Result<Vec<ReducerEvent>, Upstreamcontinue;}- if t == "response.failed" || t == "response.error" || t == "error" {- let msg = p- .get("response")- .and_then(|r| r.get("error"))- .and_then(|e| e.get("message"))- .and_then(|v| v.as_str())- .or_else(|| {- p.get("error")- .and_then(|e| e.get("message"))- .and_then(|v| v.as_str())- })- .unwrap_or("Upstream error");- let kind = upstream_failure_kind(&p, msg);- let retry_after = retry_after_from_payload(&p);- return Err(UpstreamStreamError {- kind,- message: msg.to_string(),- retry_after_seconds: retry_after,- diagnostics: None,- });- }-if t == "response.output_item.added" {let item = match p.get("item") {Some(v) => v,@@ -775,9 +797,7 @@ pub fn reduce_upstream_bytes(input: &[u8]) -> Result<Vec<ReducerEvent>, Upstream.and_then(|v| v.as_str()).map(|s| s.to_string());final_usage = p.get("response").map(parse_codex_usage);- if response_is_incomplete(&p, &t) {- incomplete = true;- }+ incomplete = response_is_incomplete_terminal(&p);continuation_eligible =(t == "response.completed" || t == "response.done") && !incomplete;continue;@@ -889,21 +909,6 @@ fn parse_codex_usage(response: &serde_json::Value) -> CodexUsage {}}-fn response_is_incomplete(payload: &serde_json::Value, event_type: &str) -> bool {- event_type == "response.incomplete"- || payload- .get("response")- .and_then(|r| r.get("status"))- .and_then(|v| v.as_str())- == Some("incomplete")- || payload- .get("response")- .and_then(|r| r.get("incomplete_details"))- .and_then(|d| d.get("reason"))- .and_then(|v| v.as_str())- .is_some()-}-fn should_buffer_tool_args(name: &str) -> bool {name == "Read"}@@ -1008,82 +1013,6 @@ fn server_tool_use_id_from_codex_web_search_id(id: &str) -> String {format!("srvtoolu_{suffix}")}-fn upstream_failure_kind(payload: &serde_json::Value, message: &str) -> UpstreamErrorKind {- let status = payload- .get("status")- .or_else(|| payload.get("status_code"))- .and_then(|v| v.as_u64());- let code = payload- .get("response")- .and_then(|r| r.get("error"))- .and_then(|e| e.get("code"))- .or_else(|| payload.get("error").and_then(|e| e.get("code")))- .and_then(|v| v.as_str());- let err_type = payload- .get("response")- .and_then(|r| r.get("error"))- .and_then(|e| e.get("type"))- .or_else(|| payload.get("error").and_then(|e| e.get("type")))- .and_then(|v| v.as_str());- let lower_msg = message.to_lowercase();-- if status == Some(529)- || code == Some("overloaded_error")- || err_type == Some("overloaded_error")- || lower_msg.contains("overloaded")- {- return UpstreamErrorKind::Overloaded;- }-- if (status.is_some_and(|s| (500..600).contains(&s)))- || code == Some("server_error")- || code == Some("internal_server_error")- || code == Some("internal_error")- || err_type == Some("server_error")- || err_type == Some("internal_server_error")- || err_type == Some("internal_error")- || is_retryable_transport_message(&lower_msg)- {- return UpstreamErrorKind::Transient;- }-- UpstreamErrorKind::Failed-}--fn retry_after_from_payload(payload: &serde_json::Value) -> Option<u64> {- let raw = payload- .get("response")- .and_then(|r| r.get("error"))- .and_then(|e| e.get("retry_after_seconds"))- .or_else(|| {- payload- .get("error")- .and_then(|e| e.get("retry_after_seconds"))- })- .or_else(|| payload.get("retry_after_seconds"))- .or_else(|| payload.get("headers").and_then(|h| h.get("retry-after")))- .or_else(|| payload.get("headers").and_then(|h| h.get("Retry-After")));- let value = match raw {- Some(v) if v.is_number() => v.as_f64(),- Some(v) if v.is_string() => v.as_str().and_then(|s| s.parse::<f64>().ok()),- _ => None,- };- value.map(|f| f as u64)-}--fn is_retryable_transport_message(msg: &str) -> bool {- msg.contains("you can retry your request")- || msg.contains("socket connection was closed unexpectedly")- || msg.contains("connection closed unexpectedly")- || msg.contains("connection reset")- || msg.contains("operation timed out")- || msg.contains("econnreset")- || msg.contains("epipe")- || msg.contains("etimedout")- || msg.contains("und_err_socket")- || msg.contains("fetch failed")-}-pub fn map_codex_usage_to_anthropic(u: &Option<CodexUsage>,web_search_requests: Option<usize>,@@ -1239,14 +1168,21 @@ mod tests {}#[test]- fn reduce_rate_limit_throws() {- let upstream = sse(- "codex.rate_limits",- json!({"rate_limits":{"limit_reached":true,"primary":{"reset_after_seconds":30}}}),+ fn reduce_rate_limit_snapshot_is_progress_telemetry() {+ let upstream = format!(+ "{}{}",+ sse(+ "codex.rate_limits",+ json!({"rate_limits":{"limit_reached":true,"primary":{"reset_after_seconds":30}}}),+ ),+ sse(+ "response.completed",+ json!({"response":{"id":"resp_1","status":"completed","usage":{}}}),+ ));- let result = reduce_upstream_bytes(upstream.as_bytes());- assert!(result.is_err());- assert_eq!(result.unwrap_err().kind, UpstreamErrorKind::RateLimit);+ let out = reduce_upstream_bytes(upstream.as_bytes()).unwrap();+ assert!(matches!(out.first(), Some(ReducerEvent::Progress)));+ assert!(matches!(out.last(), Some(ReducerEvent::Finish { .. })));}#[test]@@ -1392,26 +1328,163 @@ mod tests {}#[test]- fn reduce_incomplete_is_max_tokens() {+ fn reduce_incomplete_is_upstream_error() {let upstream = sse("response.incomplete",json!({"response":{"id":"resp_1","status":"incomplete","incomplete_details":{"reason":"max_output_tokens"},"usage":{}}}),);- let out = reduce_upstream_bytes(upstream.as_bytes()).unwrap();- let last = out.last().unwrap();- if let ReducerEvent::Finish {+ let err = reduce_upstream_bytes(upstream.as_bytes()).unwrap_err();+ assert_eq!(err.kind, UpstreamErrorKind::Transient);+ assert!(err.message.contains("max_output_tokens"));+ }++ #[test]+ fn standard_responses_policy_maps_max_output_tokens_to_finish() {+ let upstream = sse(+ "response.incomplete",+ json!({"response":{"id":"resp_1","status":"incomplete","error":null,"incomplete_details":{"reason":"max_output_tokens"},"usage":{"input_tokens":2,"output_tokens":8}}}),+ );+ let out = reduce_upstream_bytes_with_policy(+ upstream.as_bytes(),+ IncompleteResponsePolicy::AllowMaxOutputTokens,+ )+ .unwrap();+ let Some(ReducerEvent::Finish {stop_reason,+ terminal_type,continuation_eligible,+ usage,..- } = last- {- assert_eq!(*stop_reason, "max_tokens");- assert!(!continuation_eligible);- } else {+ }) = out.last()+ else {panic!("expected Finish");+ };+ assert_eq!(*stop_reason, STOP_MAX_TOKENS);+ assert_eq!(terminal_type, TERM_INCOMPLETE);+ assert!(!continuation_eligible);+ assert_eq!(+ usage.as_ref().and_then(|usage| usage.output_tokens),+ Some(8)+ );+ }++ #[test]+ fn standard_responses_policy_rejects_a_second_terminal_event() {+ let upstream = format!(+ "{}{}",+ sse(+ "response.incomplete",+ json!({"response":{"id":"resp_1","status":"incomplete","incomplete_details":{"reason":"max_output_tokens"},"usage":{}}}),+ ),+ sse(+ "response.completed",+ json!({"response":{"id":"resp_1","status":"completed","usage":{}}}),+ ),+ );+ let err = reduce_upstream_bytes_with_policy(+ upstream.as_bytes(),+ IncompleteResponsePolicy::AllowMaxOutputTokens,+ )+ .unwrap_err();+ assert_eq!(err.kind, UpstreamErrorKind::Transient);+ assert!(err.message.contains("multiple terminal"));+ }++ #[test]+ fn standard_responses_policy_rejects_content_after_terminal() {+ let trailing_events = [+ (+ "response.output_text.delta",+ json!({"output_index":0,"delta":"late"}),+ ),+ (+ "response.output_item.added",+ json!({+ "output_index":0,+ "item":{"type":"message","id":"msg_late"}+ }),+ ),+ ];++ for (event_type, payload) in trailing_events {+ let upstream = format!(+ "{}{}",+ sse(+ "response.incomplete",+ json!({"response":{"id":"resp_1","status":"incomplete","incomplete_details":{"reason":"max_output_tokens"},"usage":{}}}),+ ),+ sse(event_type, payload),+ );+ let err = reduce_upstream_bytes_with_policy(+ upstream.as_bytes(),+ IncompleteResponsePolicy::AllowMaxOutputTokens,+ )+ .unwrap_err();++ assert_eq!(err.kind, UpstreamErrorKind::Transient);+ assert!(err.message.contains("after the terminal"));+ let diagnostics = err.diagnostics.expect("expected diagnostics");+ assert_eq!(diagnostics.event_count, 2);+ assert_eq!(diagnostics.last_event_type.as_deref(), Some(event_type));+ assert!(diagnostics.saw_terminal_event);}}+ #[test]+ fn completed_terminal_followed_by_done_marker_remains_valid() {+ let upstream = format!(+ "{}data: [DONE]\n\n",+ sse(+ "response.completed",+ json!({"response":{"id":"resp_1","status":"completed","usage":{}}}),+ ),+ );++ let out = reduce_upstream_bytes(upstream.as_bytes()).unwrap();+ let Some(ReducerEvent::Finish { stop_reason, .. }) = out.last() else {+ panic!("expected Finish");+ };+ assert_eq!(*stop_reason, STOP_END_TURN);+ }++ #[test]+ fn standard_responses_max_tokens_takes_priority_over_tool_use() {+ let upstream = format!(+ "{}{}{}{}",+ sse(+ "response.output_item.added",+ json!({+ "output_index":0,+ "item":{"type":"function_call","call_id":"call_1","name":"Read"}+ }),+ ),+ sse(+ "response.function_call_arguments.delta",+ json!({"output_index":0,"delta":"{}"}),+ ),+ sse(+ "response.output_item.done",+ json!({+ "output_index":0,+ "item":{"type":"function_call","call_id":"call_1","name":"Read","arguments":"{}"}+ }),+ ),+ sse(+ "response.incomplete",+ json!({"response":{"id":"resp_1","status":"incomplete","incomplete_details":{"reason":"max_output_tokens"},"usage":{}}}),+ ),+ );+ let out = reduce_upstream_bytes_with_policy(+ upstream.as_bytes(),+ IncompleteResponsePolicy::AllowMaxOutputTokens,+ )+ .unwrap();+ let Some(ReducerEvent::Finish { stop_reason, .. }) = out.last() else {+ panic!("expected Finish");+ };+ assert_eq!(*stop_reason, STOP_MAX_TOKENS);+ }+#[test]fn reduce_completed_with_null_incomplete_details_is_end_turn() {let upstream = sse(diff --git a/src/providers/codex/websocket.rs b/src/providers/codex/websocket.rsindex f0fa6f2..9e0d33f 100644--- a/src/providers/codex/websocket.rs+++ b/src/providers/codex/websocket.rs@@ -57,14 +57,6 @@ const WEBSOCKET_CONNECT_FORBIDDEN_COOLDOWN: Duration = Duration::from_secs(3);const WEBSOCKET_KEEPALIVE_INTERVAL: Duration = Duration::from_secs(30);const WEBSOCKET_KEEPALIVE_SEND_TIMEOUT: Duration = Duration::from_secs(10);-// Terminal WebSocket event types that signal the request is done-const TERMINAL_EVENTS: &[&str] = &[- "response.completed",- "response.incomplete",- "response.failed",- "error",-];-pub type CodexWebSocketEventReceiver =tokio::sync::mpsc::Receiver<Result<serde_json::Value, CodexError>>;@@ -687,10 +679,7 @@ fn encode_sse(text: &str) -> Vec<u8> {// ---------------------------------------------------------------------------pub(super) fn is_terminal_event(payload: &serde_json::Value) -> bool {- match payload.get("type").and_then(|v| v.as_str()) {- Some(t) => TERMINAL_EVENTS.contains(&t),- None => false,- }+ super::events::event_is_terminal(payload)}fn is_response_event(payload: &serde_json::Value) -> bool {@@ -3144,11 +3133,20 @@ mod tests {let completed = serde_json::json!({"type": "response.completed"});assert!(is_terminal_event(&completed));+ let done = serde_json::json!({"type": "response.done"});+ assert!(is_terminal_event(&done));+let delta = serde_json::json!({"type": "response.output_text.delta"});assert!(!is_terminal_event(&delta));let error = serde_json::json!({"type": "error", "error": {"message": "fail"}});assert!(is_terminal_event(&error));++ let response_error = serde_json::json!({+ "type": "response.error",+ "response": {"error": {"message": "fail"}}+ });+ assert!(is_terminal_event(&response_error));}#[test]diff --git a/src/providers/opencode/mod.rs b/src/providers/opencode/mod.rsindex f9fc869..cdc1b56 100644--- a/src/providers/opencode/mod.rs+++ b/src/providers/opencode/mod.rs@@ -22,10 +22,7 @@ use crate::provider::{CliHandlers, Generation, GenerationBody, Provider, ProviderError, ProviderErrorKind,RequestContext,};-use crate::providers::{- codex::translate::accumulate::accumulate_response as accumulate_responses_response,- kimi::count_tokens,-};+use crate::providers::kimi::count_tokens;use self::client::{OpenCodeClient, OpenCodeError};use self::model::EndpointKind;@@ -149,7 +146,7 @@ impl OpenCodeProvider {Err(error) => return map_error(error),};capture_buffered_upstream(&ctx, &bytes, "sse");- match accumulate_responses_response(&bytes, &message_id, requested) {+ match responses::accumulate_response(&bytes, &message_id, requested) {Ok(value) => value,Err(error) => return invalid_upstream_response(error),}@@ -553,6 +550,29 @@ mod tests {.into_response();}if uri.path().ends_with("/responses") {+ if body["max_output_tokens"] == 8 {+ return (+ [(http::header::CONTENT_TYPE, "text/event-stream")],+ concat!(+ "data: {\"type\":\"response.output_item.added\",\"output_index\":0,\"item\":{\"type\":\"message\",\"id\":\"msg_limited\"}}\n\n",+ "data: {\"type\":\"response.output_text.delta\",\"output_index\":0,\"delta\":\"truncated response\"}\n\n",+ "data: {\"type\":\"response.output_item.done\",\"output_index\":0,\"item\":{\"type\":\"message\"}}\n\n",+ "data: {\"type\":\"response.incomplete\",\"response\":{\"id\":\"resp_limited\",\"status\":\"incomplete\",\"error\":null,\"incomplete_details\":{\"reason\":\"max_output_tokens\"},\"usage\":{\"input_tokens\":6,\"output_tokens\":8}}}\n\n",+ "data: [DONE]\n\n"+ ),+ )+ .into_response();+ }+ if body["max_output_tokens"] == 9 {+ return (+ [(http::header::CONTENT_TYPE, "text/event-stream")],+ concat!(+ "data: {\"type\":\"response.incomplete\",\"response\":{\"id\":\"resp_filtered\",\"status\":\"incomplete\",\"error\":null,\"incomplete_details\":{\"reason\":\"content_filter\"},\"usage\":{\"input_tokens\":6,\"output_tokens\":0}}}\n\n",+ "data: [DONE]\n\n"+ ),+ )+ .into_response();+ }return ([(http::header::CONTENT_TYPE, "text/event-stream")],concat!(@@ -687,6 +707,79 @@ mod tests {server.abort();}+ #[tokio::test]+ async fn responses_max_output_tokens_is_a_normal_buffered_completion() {+ let (provider, server) = mock_provider().await;+ let body: MessagesRequest = serde_json::from_value(json!({+ "model": "opencode-go/gpt-5.6-luna",+ "stream": false,+ "max_tokens": 8,+ "messages": [{"role":"user","content":"write a long response"}]+ }))+ .unwrap();+ let response = provider.handle_messages(body, context()).await;+ assert_eq!(response.status(), StatusCode::OK);+ let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)+ .await+ .unwrap();+ let value: serde_json::Value = serde_json::from_slice(&bytes).unwrap();+ assert_eq!(value["content"][0]["text"], "truncated response");+ assert_eq!(value["stop_reason"], "max_tokens");+ assert_eq!(value["usage"]["output_tokens"], 8);+ server.abort();+ }++ #[tokio::test]+ async fn responses_max_output_tokens_is_a_normal_streaming_completion() {+ let (provider, server) = mock_provider().await;+ let body: MessagesRequest = serde_json::from_value(json!({+ "model": "opencode-go/gpt-5.6-luna",+ "max_tokens": 8,+ "messages": [{"role":"user","content":"write a long response"}]+ }))+ .unwrap();+ let generation = provider+ .generate_anthropic_stream(body, context())+ .await+ .unwrap();+ let GenerationBody::LiveSse(body) = generation.body else {+ panic!("OpenCode Go generation must remain live");+ };+ let bytes = axum::body::to_bytes(body, usize::MAX).await.unwrap();+ let output = String::from_utf8(bytes.to_vec()).unwrap();+ assert!(output.contains("truncated response"));+ assert!(output.contains(r#""stop_reason":"max_tokens""#));+ assert!(output.contains("event: message_stop"));+ assert!(!output.contains("event: error"));+ server.abort();+ }++ #[tokio::test]+ async fn responses_content_filter_is_not_misreported_as_max_tokens() {+ let (provider, server) = mock_provider().await;+ let body: MessagesRequest = serde_json::from_value(json!({+ "model": "opencode-go/gpt-5.6-luna",+ "stream": false,+ "max_tokens": 9,+ "messages": [{"role":"user","content":"hello"}]+ }))+ .unwrap();+ let response = provider.handle_messages(body, context()).await;+ assert_eq!(response.status(), StatusCode::BAD_GATEWAY);+ let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)+ .await+ .unwrap();+ let value: serde_json::Value = serde_json::from_slice(&bytes).unwrap();+ assert_eq!(value["error"]["type"], "api_error");+ assert!(+ value["error"]["message"]+ .as_str()+ .unwrap()+ .contains("content_filter")+ );+ server.abort();+ }+#[tokio::test]async fn streaming_contract_covers_all_three_upstream_protocols() {let (provider, server) = mock_provider().await;diff --git a/src/providers/opencode/responses.rs b/src/providers/opencode/responses.rsindex 3cf84ea..e7f82e8 100644--- a/src/providers/opencode/responses.rs+++ b/src/providers/opencode/responses.rs@@ -8,6 +8,7 @@ use futures_util::StreamExt;use crate::anthropic::schema::MessagesRequest;use crate::monitor::{MonitorHandle, usage_from_anthropic_sse};use crate::providers::codex::translate::{+ IncompleteResponsePolicy, accumulate::accumulate_response_with_policy,live_stream::LiveStreamTranslator, request::translate_openai_compatible_request,};use crate::providers::grok::translate::stream::SseDecoder;@@ -28,6 +29,19 @@ pub fn prepare_request(Ok(value)}+pub fn accumulate_response(+ upstream: &[u8],+ message_id: &str,+ model: &str,+) -> anyhow::Result<serde_json::Value> {+ accumulate_response_with_policy(+ upstream,+ message_id,+ model,+ IncompleteResponsePolicy::AllowMaxOutputTokens,+ )+}+pub fn stream_body(upstream: OpenCodeResponse,message_id: String,@@ -39,7 +53,8 @@ pub fn stream_body(let state = ResponsesStreamState {upstream: upstream.into_stream(),decoder: SseDecoder::default(),- translator: LiveStreamTranslator::new(message_id, model),+ translator: LiveStreamTranslator::new(message_id, model)+ .with_incomplete_response_policy(IncompleteResponsePolicy::AllowMaxOutputTokens),terminal: false,error_sent: false,monitor,diff --git a/tests/codex_agent_continuation.rs b/tests/codex_agent_continuation.rsindex 5a99c1a..49c301a 100644--- a/tests/codex_agent_continuation.rs+++ b/tests/codex_agent_continuation.rs@@ -236,8 +236,16 @@ impl PendingRequest {self.outcome.send(MockOutcome::RawEvent {event: json!({- "type": "codex.rate_limits",- "rate_limits": {"allowed": false, "limit_reached": true}+ "type": "response.failed",+ "response": {+ "status": "failed",+ "error": {+ "status": 429,+ "code": "rate_limit_exceeded",+ "message": "rate limit exceeded",+ "retry_after_seconds": 0+ }+ }}),acknowledged,})diff --git a/tests/smoke_cutover.rs b/tests/smoke_cutover.rsindex 9f53bc5..12f1622 100644--- a/tests/smoke_cutover.rs+++ b/tests/smoke_cutover.rs@@ -219,6 +219,91 @@ async fn spawn_truncated_http_upstream(body: &'static [u8]) -> String {format!("http://{addr}")}+async fn spawn_retrying_truncated_http_upstream(+ first_body: Vec<u8>,+ success_body: Vec<u8>,+ attempts: Arc<AtomicUsize>,+) -> String {+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();+ let addr = listener.local_addr().unwrap();++ tokio::spawn(async move {+ for attempt in 0..2 {+ let Ok((mut stream, _)) = listener.accept().await else {+ return;+ };+ let mut request = [0_u8; 8192];+ let _ = stream.read(&mut request).await;+ attempts.fetch_add(1, Ordering::SeqCst);+ let body = if attempt == 0 {+ first_body.as_slice()+ } else {+ success_body.as_slice()+ };+ let content_length = if attempt == 0 {+ body.len() + 4096+ } else {+ body.len()+ };+ let headers = format!(+ "HTTP/1.1 200 OK\r\ncontent-type: text/event-stream\r\ncontent-length: {content_length}\r\nconnection: close\r\n\r\n"+ );+ let _ = stream.write_all(headers.as_bytes()).await;+ let _ = stream.write_all(body).await;+ let _ = stream.shutdown().await;+ }+ });++ format!("http://{addr}")+}++#[allow(clippy::await_holding_lock)]+async fn assert_codex_http_retries_structural_body_error(first_body: 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 success_body = 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();+ let upstream =+ spawn_retrying_truncated_http_upstream(first_body, success_body, attempts.clone()).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);+}+#[allow(clippy::await_holding_lock)]async fn assert_codex_http_presemantic_retry(first_response: Vec<u8>) {let _guard = env_lock();@@ -599,6 +684,23 @@ async fn spawn_websocket_close_then_retry_upstream(captured: Arc<Mutex<Vec<Value}if handled == 1 {+ for event in [+ json!({+ "type": "response.created",+ "response": {"id": "resp_aborted"}+ }),+ json!({+ "type": "response.output_item.added",+ "output_index": 0,+ "item": {+ "type": "function_call",+ "call_id": "call_aborted",+ "name": "Read"+ }+ }),+ ] {+ let _ = sender.send(Message::Text(event.to_string())).await;+ }handled += 1;let _ = sender.close().await;break;@@ -1717,6 +1819,166 @@ async fn smoke_codex_http_retries_presemantic_eof() {.await;}+#[allow(clippy::await_holding_lock)]+#[tokio::test]+async fn smoke_codex_http_retries_body_error_after_structural_message() {+ assert_codex_http_retries_structural_body_error(+ concat!(+ "data: {\"type\":\"response.created\",\"response\":{\"id\":\"resp_structural\"}}\n\n",+ "data: {\"type\":\"response.output_item.added\",\"output_index\":0,\"item\":{\"type\":\"message\",\"id\":\"msg_structural\"}}\n\n"+ )+ .as_bytes()+ .to_vec(),+ )+ .await;+}++#[allow(clippy::await_holding_lock)]+#[tokio::test]+async fn smoke_codex_http_retries_body_error_after_structural_tool() {+ assert_codex_http_retries_structural_body_error(+ concat!(+ "data: {\"type\":\"response.created\",\"response\":{\"id\":\"resp_structural\"}}\n\n",+ "data: {\"type\":\"response.output_item.added\",\"output_index\":0,\"item\":{\"type\":\"function_call\",\"call_id\":\"call_structural\",\"name\":\"Read\"}}\n\n"+ )+ .as_bytes()+ .to_vec(),+ )+ .await;+}++#[allow(clippy::await_holding_lock)]+#[tokio::test]+async fn smoke_codex_http_incomplete_after_text_is_an_error() {+ let _guard = env_lock();+ clear_all_continuations_for_tests();+ let config = TempDir::new().unwrap();+ write_auth(config.path(), "codex");++ let upstream = spawn_http_upstream(|_body: Value| {+ concat!(+ "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.output_item.done\",\"output_index\":0,\"item\":{\"type\":\"message\"}}\n\n",+ "data: {\"type\":\"response.incomplete\",\"response\":{\"status\":\"incomplete\",\"incomplete_details\":{\"reason\":\"content_filter\"}}}\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 = axum::body::to_bytes(response.into_body(), usize::MAX)+ .await+ .unwrap();+ let text = String::from_utf8_lossy(&body);+ assert!(text.contains("partial output"), "stream body: {text}");+ assert!(text.contains("event: error"), "stream body: {text}");+ assert!(text.contains("content_filter"), "stream body: {text}");+ assert!(!text.contains("event: message_stop"), "stream body: {text}");+ assert!(+ !text.contains("\"stop_reason\":\"max_tokens\""),+ "stream body: {text}"+ );+}++#[allow(clippy::await_holding_lock)]+#[tokio::test]+async fn smoke_codex_http_preserves_permanent_policy_failure() {+ 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);+ "data: {\"type\":\"response.failed\",\"response\":{\"status\":\"failed\",\"error\":{\"code\":\"cyber_policy\",\"message\":\"request rejected by policy\"}}}\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("gpt-5.5").await;++ assert_eq!(attempts.load(Ordering::SeqCst), 1);+ assert_eq!(response.status(), StatusCode::BAD_REQUEST);+ let body = axum::body::to_bytes(response.into_body(), usize::MAX)+ .await+ .unwrap();+ let value: Value = serde_json::from_slice(&body).unwrap();+ assert_eq!(value["error"]["type"], "invalid_request_error");+ assert_eq!(value["error"]["message"], "request rejected by policy");+}++#[allow(clippy::await_holding_lock)]+#[tokio::test]+async fn smoke_codex_http_rate_limit_snapshot_does_not_end_response() {+ 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\":\"codex.rate_limits\",\"rate_limits\":{\"limit_reached\":true,\"primary\":{\"reset_after_seconds\":60}}}\n\n",+ "data: {\"type\":\"response.output_item.added\",\"output_index\":0,\"item\":{\"type\":\"message\",\"id\":\"msg_after_rate\"}}\n\n",+ "data: {\"type\":\"response.output_text.delta\",\"output_index\":0,\"delta\":\"completed after telemetry\"}\n\n",+ "data: {\"type\":\"response.output_item.done\",\"output_index\":0,\"item\":{\"type\":\"message\"}}\n\n",+ "data: {\"type\":\"response.completed\",\"response\":{\"id\":\"resp_after_rate\",\"status\":\"completed\"}}\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 = axum::body::to_bytes(response.into_body(), usize::MAX)+ .await+ .unwrap();+ let text = String::from_utf8_lossy(&body);+ assert_eq!(attempts.load(Ordering::SeqCst), 1, "stream body: {text}");+ assert!(+ text.contains("completed after telemetry"),+ "stream body: {text}"+ );+ assert!(text.contains("event: message_stop"), "stream body: {text}");+ assert!(!text.contains("event: error"), "stream body: {text}");+}+#[allow(clippy::await_holding_lock)]#[tokio::test]async fn smoke_codex_http_bounds_initial_status_retries() {@@ -1980,6 +2242,47 @@ async fn smoke_codex_http_body_error_after_semantic_output_preserves_message() {);}+#[allow(clippy::await_holding_lock)]+#[tokio::test]+async fn smoke_codex_http_body_error_after_closed_tool_is_not_success() {+ let _guard = env_lock();+ clear_all_continuations_for_tests();+ let config = TempDir::new().unwrap();+ write_auth(config.path(), "codex");++ let upstream = spawn_truncated_http_upstream(concat!(+ "data: {\"type\":\"response.created\",\"response\":{\"id\":\"resp_tool_partial\"}}\n\n",+ "data: {\"type\":\"response.output_item.added\",\"output_index\":0,\"item\":{\"type\":\"function_call\",\"call_id\":\"call_partial\",\"name\":\"Read\"}}\n\n",+ "data: {\"type\":\"response.function_call_arguments.delta\",\"output_index\":0,\"delta\":\"{\\\"file_path\\\":\\\"/tmp/example\\\"}\"}\n\n",+ "data: {\"type\":\"response.output_item.done\",\"output_index\":0,\"item\":{\"type\":\"function_call\",\"call_id\":\"call_partial\",\"name\":\"Read\",\"arguments\":\"{\\\"file_path\\\":\\\"/tmp/example\\\"}\"}}\n\n"+ ).as_bytes())+ .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":"read a file"}]+ }))+ .await;++ assert_eq!(response.status(), StatusCode::OK);+ let body = axum::body::to_bytes(response.into_body(), usize::MAX)+ .await+ .unwrap();+ let text = String::from_utf8_lossy(&body);+ assert!(text.contains("\"name\":\"Read\""), "stream body: {text}");+ assert!(text.contains("event: error"), "stream body: {text}");+ assert!(+ text.contains("Transport error reading Codex response body"),+ "stream body: {text}"+ );+ assert!(!text.contains("event: message_stop"), "stream body: {text}");+}+#[allow(clippy::await_holding_lock)]#[tokio::test]async fn smoke_codex_http_truncated_upstream_writes_reducer_diagnostic() {@@ -2341,7 +2644,6 @@ async fn smoke_codex_websocket_stream_retries_missing_previous_response_id() {"second response body: {}",String::from_utf8_lossy(&second_body));-let guard = captured.lock().unwrap();assert_eq!(guard.len(), 3, "expected retry websocket request");assert!(guard[0].get("previous_response_id").is_none());@@ -2406,6 +2708,20 @@ async fn smoke_codex_websocket_stream_retries_empty_close_with_full_context() {"second response body: {}",String::from_utf8_lossy(&second_body));+ let second_text = String::from_utf8_lossy(&second_body);+ assert!(+ !second_text.contains("call_aborted"),+ "stream body: {second_text}"+ );+ assert!(+ !second_text.contains(r#""name":"Read""#),+ "stream body: {second_text}"+ );+ assert!(+ !second_text.contains("event: error"),+ "stream body: {second_text}"+ );+ assert_eq!(second_text.matches("event: content_block_start").count(), 1);let guard = captured.lock().unwrap();assert_eq!(guard.len(), 3, "expected full-context retry request");