mirror of
https://github.com/pchuan98/codex.git
synced 2026-07-01 00:31:56 +08:00
rhan-oai
04a8580f33
## Why #23951 added remote compaction v2 retries, but it left the retry and WS -> HTTPS fallback behavior duplicated between normal Responses turns and compaction. This follow-up centralizes the common retry handling so future changes to fallback, retry delay, retry notifications, and retry sleep do not have to be kept in sync across both callsites. ## What changed - Added `core/src/responses_retry.rs` with a shared handler for retryable Responses stream errors. - Reused that handler from normal turn sampling and remote compaction v2. - Kept each callsite responsible for its retry budget: normal turns still use `stream_max_retries`, while compaction v2 still uses `min(stream_max_retries, 2)`. - Preserved caller-specific behavior around non-retryable errors, context-window errors, usage-limit errors, and compact-specific final failure logging. The shared handler now owns: - WS -> HTTPS fallback warning emission - retry delay selection, including server-requested stream retry delay - retry logging - first-WebSocket-retry notification suppression - `Reconnecting... n/max` stream-error notification - sleeping before the next retry attempt ## Verification - `cargo test -p codex-core remote_compact_v2` - `cargo test -p codex-core websocket_fallback` - `just fix -p codex-core` Did not run the full workspace test suite. --------- Co-authored-by: jif-oai <jif@openai.com>
106 lines
3.2 KiB
Rust
106 lines
3.2 KiB
Rust
//! Shared retry and transport fallback decisions for Responses requests.
|
|
|
|
use std::time::Duration;
|
|
|
|
use crate::client::ModelClientSession;
|
|
use crate::session::session::Session;
|
|
use crate::session::turn_context::TurnContext;
|
|
use crate::util::backoff;
|
|
use codex_protocol::error::CodexErr;
|
|
use codex_protocol::protocol::EventMsg;
|
|
use codex_protocol::protocol::WarningEvent;
|
|
use tracing::warn;
|
|
|
|
#[derive(Debug, Clone, Copy)]
|
|
pub(crate) enum ResponsesStreamRequest {
|
|
Sampling,
|
|
RemoteCompactionV2,
|
|
}
|
|
|
|
/// Handles a retryable stream error and returns `Ok(())` when the caller should
|
|
/// retry the request loop.
|
|
pub(crate) async fn handle_retryable_response_stream_error(
|
|
retries: &mut u64,
|
|
max_retries: u64,
|
|
err: CodexErr,
|
|
client_session: &mut ModelClientSession,
|
|
sess: &Session,
|
|
turn_context: &TurnContext,
|
|
request: ResponsesStreamRequest,
|
|
) -> Result<(), CodexErr> {
|
|
if *retries >= max_retries
|
|
&& client_session.try_switch_fallback_transport(
|
|
&turn_context.session_telemetry,
|
|
&turn_context.model_info,
|
|
)
|
|
{
|
|
sess.send_event(
|
|
turn_context,
|
|
EventMsg::Warning(WarningEvent {
|
|
message: format!("Falling back from WebSockets to HTTPS transport. {err:#}"),
|
|
}),
|
|
)
|
|
.await;
|
|
*retries = 0;
|
|
return Ok(());
|
|
}
|
|
|
|
if *retries < max_retries {
|
|
*retries += 1;
|
|
let retry_count = *retries;
|
|
let delay = match &err {
|
|
CodexErr::Stream(_, requested_delay) => {
|
|
requested_delay.unwrap_or_else(|| backoff(retry_count))
|
|
}
|
|
_ => backoff(retry_count),
|
|
};
|
|
log_retry(request, turn_context, &err, retry_count, max_retries, delay);
|
|
|
|
// In release builds, hide the first websocket retry notification to reduce noisy
|
|
// transient reconnect messages. In debug builds, keep full visibility for diagnosis.
|
|
let report_error = retry_count > 1
|
|
|| cfg!(debug_assertions)
|
|
|| !sess.services.model_client.responses_websocket_enabled();
|
|
if report_error {
|
|
// Surface retry information to any UI/front-end so the user understands what is
|
|
// happening instead of staring at a seemingly frozen screen.
|
|
sess.notify_stream_error(
|
|
turn_context,
|
|
format!("Reconnecting... {retry_count}/{max_retries}"),
|
|
err,
|
|
)
|
|
.await;
|
|
}
|
|
tokio::time::sleep(delay).await;
|
|
return Ok(());
|
|
}
|
|
|
|
Err(err)
|
|
}
|
|
|
|
fn log_retry(
|
|
request: ResponsesStreamRequest,
|
|
turn_context: &TurnContext,
|
|
err: &CodexErr,
|
|
retries: u64,
|
|
max_retries: u64,
|
|
delay: Duration,
|
|
) {
|
|
match request {
|
|
ResponsesStreamRequest::Sampling => {
|
|
warn!(
|
|
"stream disconnected - retrying sampling request ({retries}/{max_retries} in {delay:?})...",
|
|
);
|
|
}
|
|
ResponsesStreamRequest::RemoteCompactionV2 => {
|
|
warn!(
|
|
turn_id = %turn_context.sub_id,
|
|
retries,
|
|
max_retries,
|
|
compact_error = %err,
|
|
"remote compaction v2 stream failed; retrying request after delay"
|
|
);
|
|
}
|
|
}
|
|
}
|