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;