From 5630d58680af22b71dc0d435049d2a16ec9dace4 Mon Sep 17 00:00:00 2001 From: felixxia-oai Date: Mon, 16 Nov 2026 11:38:00 +0000 Subject: [PATCH] Add a dedicated Guardian v3 housekeeper inference client (#61798) ## What changed Add a tool-free Responses sampler with persistent conversation history and whole-batch eviction to stay within the model's input budget. Parse completed routing replies and retain their output through an explicit commit step. Add WebSocket connection reuse, HTTP fallback, bounded retries, authentication recovery, account-change checks, and cancellation of unfinished responses. Register the new modules without connecting them to the existing housekeeper routing flow yet. GitOrigin-RevId: 2a0ff557a521763ab984249ec6594ae7ce09d59e --- codex-rs/Cargo.lock | 9 + codex-rs/ext/guardian-v3/Cargo.toml | 11 +- codex-rs/ext/guardian-v3/src/housekeeper.rs | 2 +- .../guardian-v3/src/housekeeper_sampler.rs | 305 +++++++++++++ .../guardian-v3/src/housekeeper_transport.rs | 419 ++++++++++++++++++ codex-rs/ext/guardian-v3/src/lib.rs | 4 + 6 files changed, 748 insertions(+), 2 deletions(-) create mode 100644 codex-rs/ext/guardian-v3/src/housekeeper_sampler.rs create mode 100644 codex-rs/ext/guardian-v3/src/housekeeper_transport.rs diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lock index 49770f46e2..6cb83ba453 100644 --- a/codex-rs/Cargo.lock +++ b/codex-rs/Cargo.lock @@ -3837,20 +3837,28 @@ dependencies = [ "anyhow", "chrono", "codex-analytics", + "codex-api", "codex-attachment-store", "codex-context-fragments", "codex-core", "codex-extension-api", + "codex-features", + "codex-guardian-context", "codex-guardian-reviewer", "codex-history", + "codex-http-client", + "codex-login", "codex-message-board", + "codex-model-provider", "codex-protocol", "codex-state", "codex-thread-store", "codex-tools", "codex-utils-string", + "codex-websocket-client", "core_test_support", "futures", + "http 1.4.0", "insta", "pretty_assertions", "serde", @@ -3860,6 +3868,7 @@ dependencies = [ "tokio", "tokio-util", "tracing", + "uuid", ] [[package]] diff --git a/codex-rs/ext/guardian-v3/Cargo.toml b/codex-rs/ext/guardian-v3/Cargo.toml index 0826ae963e..44f5e92ca9 100644 --- a/codex-rs/ext/guardian-v3/Cargo.toml +++ b/codex-rs/ext/guardian-v3/Cargo.toml @@ -14,26 +14,35 @@ workspace = true [dependencies] anyhow = { workspace = true } codex-analytics = { workspace = true } +codex-api = { workspace = true } +codex-context-fragments = { workspace = true } codex-core = { workspace = true } codex-extension-api = { workspace = true } +codex-features = { workspace = true } +codex-guardian-context = { workspace = true } codex-guardian-reviewer = { workspace = true } codex-history = { workspace = true } +codex-http-client = { workspace = true } +codex-login = { workspace = true } codex-message-board = { workspace = true } +codex-model-provider = { workspace = true } codex-protocol = { workspace = true } codex-state = { workspace = true } codex-thread-store = { workspace = true } codex-tools = { workspace = true } codex-utils-string = { workspace = true } +codex-websocket-client = { workspace = true } +http = { workspace = true } serde = { workspace = true } serde_json = { workspace = true, features = ["raw_value"] } tokio = { workspace = true, features = ["time"] } tokio-util = { workspace = true } tracing = { workspace = true } +uuid = { workspace = true } [dev-dependencies] chrono = { workspace = true } codex-attachment-store = { workspace = true } -codex-context-fragments = { workspace = true } core_test_support = { workspace = true } futures = { workspace = true } insta = { workspace = true } diff --git a/codex-rs/ext/guardian-v3/src/housekeeper.rs b/codex-rs/ext/guardian-v3/src/housekeeper.rs index 4498c8de56..e79b9b9069 100644 --- a/codex-rs/ext/guardian-v3/src/housekeeper.rs +++ b/codex-rs/ext/guardian-v3/src/housekeeper.rs @@ -49,7 +49,7 @@ struct RoutingInput<'a> { #[derive(Deserialize)] #[serde(deny_unknown_fields)] -struct RoutingOutput { +pub(super) struct RoutingOutput { routes: Vec>, descriptions: BTreeMap, } diff --git a/codex-rs/ext/guardian-v3/src/housekeeper_sampler.rs b/codex-rs/ext/guardian-v3/src/housekeeper_sampler.rs new file mode 100644 index 0000000000..5958840466 --- /dev/null +++ b/codex-rs/ext/guardian-v3/src/housekeeper_sampler.rs @@ -0,0 +1,305 @@ +//! One tool-free inference client and append-only conversation per live root worker. +//! Under window pressure only whole, completed routing batches are evicted. +use std::collections::VecDeque; +use std::sync::Arc; +use std::sync::Weak; + +use anyhow::Context; +use anyhow::ensure; +use codex_api::Reasoning; +use codex_api::ReasoningContext; +use codex_api::ResponseEvent; +use codex_api::ResponsesApiRequest; +use codex_context_fragments::AnnotatedContent; +use codex_context_fragments::message_from_parts; +use codex_core::CodexThread; +use codex_core::ThreadManager; +use codex_guardian_context::effective_input_token_limit; +use codex_guardian_context::estimate_input_tokens; +use codex_protocol::ThreadId; +use codex_protocol::models::ContentItem; +use codex_protocol::models::ContentItemKind; +use codex_protocol::models::ContentItemMetadata; +use codex_protocol::models::MessagePhase; +use codex_protocol::models::ResponseItem; +use codex_protocol::openai_models::CatalogModel; +use codex_protocol::openai_models::ReasoningEffort; +use codex_protocol::protocol::TruncationPolicy; +use serde_json::Value; + +use crate::HOUSEKEEPER_INSTRUCTIONS; +use crate::housekeeper::RoutingOutput; +use crate::housekeeper_transport::PendingResponse; +use crate::housekeeper_transport::Transport; + +pub(super) struct HousekeeperSampler { + parent: Weak, + conversation: ThreadId, + transport: Transport, + model: CatalogModel, + openai_provider: bool, + service_tier: Option, + instructions: ResponseItem, + history: Vec, + input_limit: usize, + batches: VecDeque, + retained_tokens: usize, +} + +struct RetainedBatch { + items: usize, + tokens: usize, +} + +pub(super) struct SampledBatch { + input_tokens: usize, + output: Vec, +} + +impl HousekeeperSampler { + pub(super) async fn new( + parent: &Arc, + manager: &ThreadManager, + ) -> anyhow::Result { + let config = parent.config().await; + let snapshot = parent.config_snapshot().await; + let mut settings = config.to_models_manager_config(); + // Actor window overrides apply only to the actor model. + settings.model_context_window = None; + settings.model_auto_compact_token_limit = None; + let model = manager + .models_manager_for_config(&config) + .get_model_info("gpt-5.6-luna", &settings) + .await; + let input_limit = effective_input_token_limit(&model, /*configured_window*/ None); + let mut instructions = message_from_parts( + "developer", + vec![AnnotatedContent::text( + HOUSEKEEPER_INSTRUCTIONS, + ContentItemKind("model.base_instructions".to_owned()), + ContentItemMetadata::harness(), + )], + ); + if let Some(prefix) = instructions.id_prefix() { + instructions.set_id(Some((parent.item_id_generator())(prefix))); + } + Ok(Self { + parent: Arc::downgrade(parent), + conversation: ThreadId::new(), + transport: Transport::new(parent, &config, snapshot.originator)?, + model, + openai_provider: config.model_provider.is_openai(), + service_tier: snapshot.service_tier, + instructions, + history: Vec::new(), + input_limit, + batches: VecDeque::new(), + retained_tokens: 0, + }) + } + + pub(super) fn account_changed(&self) -> impl std::future::Future + use<> { + let owner = self.transport.owner.clone(); + async move { + let Some(owner) = owner else { + return std::future::pending::<()>().await; + }; + let mut changes = owner.changes(); + while owner.is_current() { + if changes.changed().await.is_err() { + break; + } + } + } + } + + pub(super) fn input_policy(&self) -> TruncationPolicy { + self.model.truncation_policy.into() + } + + pub(super) async fn sample( + &mut self, + mut input: ResponseItem, + schema: Value, + ) -> anyhow::Result<(RoutingOutput, SampledBatch)> { + let parent = self.parent.upgrade().context("Guardian root stopped")?; + if let Some(prefix) = input.id_prefix() { + input.set_id(Some((parent.item_id_generator())(prefix))); + } + drop(parent); + let fixed_tokens = TruncationPolicy::Bytes( + HOUSEKEEPER_INSTRUCTIONS.len() + serde_json::to_vec(&schema)?.len(), + ) + .token_budget(); + let input_tokens = estimate_input_tokens(&input); + let required = fixed_tokens.saturating_add(input_tokens); + ensure!( + required <= self.input_limit, + "housekeeper batch exceeds model input window" + ); + let mut remove = 0; + while self.retained_tokens > self.input_limit - required { + let batch = self + .batches + .pop_front() + .context("inconsistent housekeeper history")?; + self.retained_tokens -= batch.tokens; + remove += batch.items; + } + self.history.drain(..remove); + self.history.push(input); + let schema = Some(schema); + let mut attempt = self.transport.start_batch(); + loop { + let result = async { + let parent = self.parent.upgrade().context("Guardian root stopped")?; + let request = self.request(&schema); + let pending = self + .transport + .stream( + &parent, + self.conversation, + &attempt, + request, + self.model.use_responses_lite, + ) + .await?; + drop(parent); + Self::read_response(pending).await + }; + match result.await { + Ok((routes, output)) => { + return Ok(( + routes, + SampledBatch { + input_tokens, + output, + }, + )); + } + Err(error) => { + if !self + .transport + .retry_after_failure(&mut attempt, &error) + .await + { + return Err(error); + } + } + } + } + } + + fn request(&self, schema: &Option) -> ResponsesApiRequest { + let mut input: Vec<_> = std::iter::once(&self.instructions) + .chain(&self.history) + .cloned() + .collect(); + for item in &mut input { + if !self.model.use_responses_lite { + item.clear_content_item_metadata(); + } + if !self.openai_provider { + item.clear_internal_chat_message_metadata_passthrough(); + if !matches!(item, ResponseItem::Reasoning { .. }) { + item.clear_encrypted_content(); + } + } + } + ResponsesApiRequest { + request_country: Default::default(), + model: self.model.slug.clone(), + input, + tools: None, + tool_choice: "none".to_owned(), + parallel_tool_calls: false, + reasoning: Some(Reasoning { + effort: Some(ReasoningEffort::Low), + summary: None, + context: self + .model + .use_responses_lite + .then_some(ReasoningContext::AllTurns), + }), + store: false, + stream: true, + stream_options: None, + include: vec!["reasoning.encrypted_content".to_owned()], + service_tier: self.service_tier.clone(), + prompt_cache_key: Some(self.conversation.to_string()), + prompt_cache_options: None, + text: codex_api::create_text_param_for_request( + /*verbosity*/ None, schema, /*output_schema_strict*/ false, + ), + client_metadata: None, + access_programs: None, + } + } + + async fn read_response( + mut pending: PendingResponse, + ) -> anyhow::Result<(RoutingOutput, Vec)> { + let mut output = Vec::new(); + while let Some(event) = pending.stream.rx_event.recv().await { + match event? { + ResponseEvent::OutputItemDone(item) => { + let retain = match &item { + ResponseItem::Reasoning { .. } => true, + ResponseItem::Message { role, content, .. } => { + role == "assistant" + && content + .iter() + .all(|part| matches!(part, ContentItem::OutputText { .. })) + } + _ => false, + }; + ensure!(retain, "unexpected item in tool-free housekeeper response"); + output.push(item); + } + ResponseEvent::Completed { + end_turn: Some(false), + .. + } => anyhow::bail!("incomplete housekeeper turn"), + ResponseEvent::Completed { .. } => { + drop(pending.stream.interrupt.take()); + let text = output + .iter() + .rev() + .find_map(|item| match item { + ResponseItem::Message { + role, + phase: None | Some(MessagePhase::FinalAnswer), + content, + .. + } if role == "assistant" => codex_core::content_items_to_text(content), + _ => None, + }) + .context("missing housekeeper routing reply")?; + let routes = serde_json::from_str(&text).map_err(|e| { + anyhow::anyhow!( + "housekeeper returned invalid JSON ({:?} at line {} column {})", + e.classify(), + e.line(), + e.column() + ) + })?; + return Ok((routes, output)); + } + _ => {} + } + } + anyhow::bail!("housekeeper response ended before completion") + } + + /// Called only after routing validation and board writes have succeeded. + pub(super) fn commit(&mut self, batch: SampledBatch) { + let output_tokens: usize = batch.output.iter().map(estimate_input_tokens).sum(); + let tokens = batch.input_tokens + output_tokens; + self.batches.push_back(RetainedBatch { + items: 1 + batch.output.len(), + tokens, + }); + self.history.extend(batch.output); + self.retained_tokens += tokens; + } +} diff --git a/codex-rs/ext/guardian-v3/src/housekeeper_transport.rs b/codex-rs/ext/guardian-v3/src/housekeeper_transport.rs new file mode 100644 index 0000000000..85daa30b80 --- /dev/null +++ b/codex-rs/ext/guardian-v3/src/housekeeper_transport.rs @@ -0,0 +1,419 @@ +//! Responses transport for one serial housekeeper. Resolve the account and route for +//! each attempt. The sampler can resend a batch after a transient failure, but only a +//! completed routing response can reach the board. +use std::sync::Arc; +use std::time::Duration; + +use anyhow::Context; +use anyhow::ensure; +use codex_api::ApiError; +use codex_api::ResponseInterrupt; +use codex_api::ResponseStream; +use codex_api::ResponsesApiRequest; +use codex_api::ResponsesClient; +use codex_api::ResponsesOptions; +use codex_api::ResponsesWebsocketClient; +use codex_api::ResponsesWebsocketConnection; +use codex_api::ResponsesWsRequest; +use codex_api::TransportError; +use codex_api::build_session_headers; +use codex_core::CodexThread; +use codex_core::config::Config; +use codex_features::Feature; +use codex_http_client::HttpClientFactory; +use codex_http_client::NetworkPolicy; +use codex_http_client::RetryAfter; +use codex_login::AgentIdentityAuthPolicy; +use codex_login::AuthOwner; +use codex_login::UnauthorizedRecovery; +use codex_login::default_client::add_originator_header; +use codex_login::default_client::default_headers; +use codex_model_provider::ProviderAuthContext; +use codex_model_provider::ProviderAuthScope; +use codex_model_provider::ResponsesConnectionKey; +use codex_model_provider::SharedModelProvider; +use codex_model_provider::WorkspaceRoutingContext; +use codex_model_provider::resolve_request; +use codex_protocol::ThreadId; +use codex_protocol::protocol::InternalSessionSource; +use codex_protocol::protocol::SessionSource; +use codex_websocket_client::WebSocketConnector; +use http::HeaderMap; +use http::HeaderValue; +use http::StatusCode; +use tokio::time::Instant; + +// Managed 401 recovery has its own bounded sequence. +const MAX_SAMPLING_RETRIES: usize = 2; + +/// One inference turn across connection attempts for the same routing batch. +pub(super) struct BatchAttempt { + turn: String, + transport_retries: usize, + auth_recovery: Option, +} + +pub(super) struct Transport { + provider: SharedModelProvider, + auth: ProviderAuthScope, + pub(super) owner: Option, + factory: HttpClientFactory, + routing: Arc, + originator: String, + connector: Option, + // Avoid paying another failed handshake on every batch of an HTTP-only endpoint. + retry_websocket: Option<(ResponsesConnectionKey, Instant)>, + socket: Option<( + ResponsesConnectionKey, + NetworkPolicy, + ResponsesWebsocketConnection, + )>, +} + +/// Interrupt an unfinished response when routing is cancelled or times out. +pub(super) struct PendingResponse { + pub(super) stream: ResponseStream, +} + +impl Drop for PendingResponse { + fn drop(&mut self) { + if let Some(interrupt) = self.stream.interrupt.take() { + let _ = interrupt.send(ResponseInterrupt::Cancel { + deadline: Instant::now() + Duration::from_secs(1), + }); + } + } +} + +impl Transport { + pub(super) fn new( + parent: &CodexThread, + config: &Config, + originator: String, + ) -> anyhow::Result { + let data = parent.thread_extension_data(); + let auth = data + .get::() + .context("missing provider authentication for Guardian routing")?; + let provider = auth.model_provider(config.model_provider.clone()); + // A provider command issues opaque bearer tokens. Rotation is expected between batches. + let owner = if provider.info().auth.is_some() { + None + } else { + codex_model_provider::request_auth_owner(provider.as_ref()) + }; + Ok(Self { + provider, + owner, + auth: ProviderAuthScope { + session_source: SessionSource::Internal(InternalSessionSource::Guardian), + agent_identity_policy: if config.features.enabled(Feature::UseAgentIdentity) { + AgentIdentityAuthPolicy::ChatGptAuth + } else { + AgentIdentityAuthPolicy::JwtOnly + }, + agent_identity_session_fallback: Default::default(), + }, + routing: data.get_or_init(|| config.workspace_routing_context()), + factory: config.http_client_factory(), + originator, + connector: None, + socket: None, + retry_websocket: None, + }) + } + + pub(super) fn start_batch(&self) -> BatchAttempt { + BatchAttempt { + turn: uuid::Uuid::now_v7().to_string(), + transport_retries: 0, + auth_recovery: self + .provider + .auth_manager() + .map(|manager| manager.unauthorized_recovery()), + } + } + + pub(super) async fn retry_after_failure( + &mut self, + attempt: &mut BatchAttempt, + error: &anyhow::Error, + ) -> bool { + if self.owner.as_ref().is_some_and(|owner| !owner.is_current()) { + return false; + } + let Some(error) = error.downcast_ref::() else { + return false; + }; + let transport_retry = match error { + ApiError::Api { status, .. } + | ApiError::Transport(TransportError::Http { status, .. }) => { + if *status == StatusCode::UNAUTHORIZED { + let Some(recovery) = &mut attempt.auth_recovery else { + return false; + }; + if !recovery.has_next() || recovery.next().await.is_err() { + return false; + } + false + } else if status.is_server_error() || *status == StatusCode::TOO_MANY_REQUESTS { + true + } else { + return false; + } + } + ApiError::Retryable { .. } + | ApiError::RateLimitExceeded { .. } + | ApiError::Stream(_) + | ApiError::WebsocketMessageTooLarge + | ApiError::ContentFilter + | ApiError::ServerOverloaded { .. } + | ApiError::PolicyCapacityUnavailable { .. } + | ApiError::FlexUnavailable + | ApiError::Transport( + TransportError::RetryLimit + | TransportError::Timeout + | TransportError::Connection(_) + | TransportError::Network(_), + ) => true, + _ => return false, + }; + if transport_retry { + if attempt.transport_retries == MAX_SAMPLING_RETRIES { + return false; + } + attempt.transport_retries += 1; + } + self.socket = None; + if let Some(advice) = retry_after(error) { + tokio::time::sleep_until(advice.deadline()).await; + } + true + } + + pub(super) async fn stream( + &mut self, + parent: &CodexThread, + conversation: ThreadId, + attempt: &BatchAttempt, + mut request: ResponsesApiRequest, + responses_lite: bool, + ) -> anyhow::Result { + let mut setup = resolve_request( + self.provider.as_ref(), + Some(self.auth.clone()), + Some(&self.routing), + self.factory.clone(), + ) + .await?; + let auth_changes = setup.auth_owner.as_ref().map(AuthOwner::changes); + let command_auth = self.provider.info().auth.is_some(); + let revision = if command_auth && setup.runtime_id.is_none() { + // The command can return a new token during resolution. Key the socket to the + // credential for this request, rather than the generation before the command ran. + let state = setup + .auth + .as_ref() + .and_then(|auth| self.provider.auth_manager()?.auth_change_state_for(auth)) + .ok_or_else(|| { + ApiError::Stream("provider credential changed during Guardian routing".into()) + })?; + Some(state.generation) + } else { + setup.auth_revision + }; + let resolved_owner = setup.auth_owner.clone(); + let check_owner = || { + ensure!( + self.owner.as_ref().is_none_or(AuthOwner::is_current) + && (command_auth + || resolved_owner + .as_ref() + .is_none_or(|owner| self.owner.as_ref() == Some(owner))), + "account changed during Guardian routing" + ); + if auth_changes + .as_ref() + .map(|changes| changes.borrow().generation) + != revision + { + return Err( + ApiError::Stream("credentials changed during Guardian routing".into()).into(), + ); + } + Ok::<(), anyhow::Error>(()) + }; + check_owner()?; + let ids = parent.startup_metadata(); + let turn = &attempt.turn; + let turn_metadata = serde_json::json!({ + "session_id": ids.session_id, "thread_id": conversation, "parent_thread_id": ids.thread_id, + "turn_id": turn, "root_turn_id": turn, "request_kind":"turn","turn_trigger":"guardian_housekeeper", + }).to_string(); + let add_guardian_headers = |headers: &mut HeaderMap| -> anyhow::Result<()> { + headers.insert("x-openai-subagent", HeaderValue::from_static("guardian")); + headers.insert( + "x-codex-parent-thread-id", + ids.thread_id.to_string().parse()?, + ); + headers.insert("x-codex-window-id", format!("{conversation}:0").parse()?); + add_originator_header(headers, &self.originator); + if responses_lite { + headers.insert( + "x-openai-internal-codex-responses-lite", + HeaderValue::from_static("true"), + ); + } + Ok(()) + }; + let mut metadata = std::collections::HashMap::from([ + ("session_id".to_owned(), ids.session_id.to_string()), + ("thread_id".to_owned(), conversation.to_string()), + ("turn_id".to_owned(), turn.to_owned()), + ("root_turn_id".to_owned(), turn.to_owned()), + ( + "x-codex-parent-thread-id".to_owned(), + ids.thread_id.to_string(), + ), + ("x-openai-subagent".to_owned(), "guardian".to_owned()), + ("x-codex-window-id".to_owned(), format!("{conversation}:0")), + ("x-codex-turn-metadata".to_owned(), turn_metadata.clone()), + ]); + if responses_lite { + metadata.insert( + "ws_request_header_x_openai_internal_codex_responses_lite".to_owned(), + "true".to_owned(), + ); + } + request.client_metadata = Some(metadata); + let key = ResponsesConnectionKey::new(&setup.api_provider, revision); + let policy = setup.http_client_factory.network_policy(); + let mut reused = false; + if let Some((old_key, old_policy, socket)) = &self.socket { + reused = setup.runtime_id.is_none() + && old_key == &key + && old_policy == policy + && !socket.is_closed().await; + if !reused { + self.socket = None; + } + } + let cooling_down = self + .retry_websocket + .as_ref() + .is_some_and(|(failed, until)| failed == &key && Instant::now() < *until); + if !reused + && attempt.transport_retries == 0 + && !cooling_down + && self.provider.info().supports_websockets + { + if self.connector.is_none() { + let factory = self.factory.clone(); + self.connector = Some( + tokio::task::spawn_blocking(move || WebSocketConnector::new(&factory)) + .await??, + ); + } + let connector = self + .connector + .as_ref() + .and_then(|connector| connector.with_account_binding(policy)) + .context("housekeeper WebSocket account policy mismatch")?; + let mut upgrade = build_session_headers( + Some(ids.session_id.to_string()), + Some(conversation.to_string()), + ); + add_guardian_headers(&mut upgrade)?; + upgrade.insert("x-client-request-id", conversation.to_string().parse()?); + upgrade.insert( + "openai-beta", + HeaderValue::from_static("responses_websockets=2026-02-06"), + ); + let ws = + ResponsesWebsocketClient::new(setup.api_provider.clone(), setup.api_auth.clone()); + check_owner()?; + match tokio::time::timeout( + self.provider.info().websocket_connect_timeout(), + ws.connect_with_connector( + &connector, + upgrade, + default_headers(), + /*turn_state*/ None, + /*telemetry*/ None, + ), + ) + .await + { + Ok(Ok(socket)) => self.socket = Some((key, policy.clone(), socket)), + Ok(Err( + error @ ApiError::Transport( + TransportError::Policy(_) | TransportError::Build(_), + ), + )) => return Err(error.into()), + Ok(Err(error @ ApiError::Transport(TransportError::Http { status, .. }))) + | Ok(Err(error @ ApiError::Api { status, .. })) + if matches!( + status, + StatusCode::UNAUTHORIZED + | StatusCode::FORBIDDEN + | StatusCode::TOO_MANY_REQUESTS + ) || (status.is_server_error() && retry_after(&error).is_some()) => + { + return Err(error.into()); + } + // As in GV2, give an unavailable upgrade five minutes before trying it again. + _ => { + self.retry_websocket = Some((key, Instant::now() + Duration::from_secs(5 * 60))) + } + } + } + check_owner()?; + let stream = if let Some((_, _, socket)) = &self.socket { + socket + .stream_request( + ResponsesWsRequest::ResponseCreate((&request).into()), + reused, + /*turn_state*/ None, + ) + .await + } else { + let mut headers = HeaderMap::new(); + add_guardian_headers(&mut headers)?; + headers.insert("x-codex-turn-metadata", turn_metadata.parse()?); + // The sampler owns retries across both transports, including stream failures. + setup.api_provider.retry.max_attempts = 0; + let http = tokio::task::spawn_blocking(move || { + let transport = setup.http_transport("/responses")?; + Ok::<_, anyhow::Error>(ResponsesClient::new( + transport, + setup.api_provider, + setup.api_auth, + )) + }) + .await??; + check_owner()?; + http.stream_request( + request, + ResponsesOptions { + session_id: Some(ids.session_id.to_string()), + thread_id: Some(conversation.to_string()), + extra_headers: headers, + ..Default::default() + }, + ) + .await + }?; + Ok(PendingResponse { stream }) + } +} + +fn retry_after(error: &ApiError) -> Option { + match error { + ApiError::Transport(error) => error.retry_after(), + ApiError::Retryable { retry_after, .. } + | ApiError::RateLimitExceeded { retry_after, .. } + | ApiError::ServerOverloaded { retry_after } + | ApiError::PolicyCapacityUnavailable { retry_after } => *retry_after, + _ => None, + } +} diff --git a/codex-rs/ext/guardian-v3/src/lib.rs b/codex-rs/ext/guardian-v3/src/lib.rs index 32920cca04..7ffaa3478d 100644 --- a/codex-rs/ext/guardian-v3/src/lib.rs +++ b/codex-rs/ext/guardian-v3/src/lib.rs @@ -12,6 +12,10 @@ mod delivery; mod evidence; mod host; mod housekeeper; +#[allow(dead_code, reason = "Wired into the housekeeper in the next PR.")] +mod housekeeper_sampler; +#[allow(dead_code, reason = "Wired into the housekeeper in the next PR.")] +mod housekeeper_transport; mod private_thread; pub use host::install; mod retrieval_tools;