Lightweight coding agent that runs in your terminal
Rust
Forward per-turn Cyber access programs to Guardian (#52689)
Dane Schneider10da56925200
diff --git a/codex-rs/app-server/tests/suite/v2/guardian_v2_model_tests.rs b/codex-rs/app-server/tests/suite/v2/guardian_v2_model_tests.rsindex 8e87490490..bf92296307 100644--- a/codex-rs/app-server/tests/suite/v2/guardian_v2_model_tests.rs+++ b/codex-rs/app-server/tests/suite/v2/guardian_v2_model_tests.rs@@ -1,16 +1,25 @@-//! Verifies model-required CUA scoring across model changes in a live thread.+//! Verifies that Guardian model and Cyber selections follow the current parent turn.use std::sync::Arc;use std::sync::Mutex;use std::sync::atomic::Ordering;use anyhow::Result;+use app_test_support::ChatGptAuthFixture;use app_test_support::MockResponsesConfig;use app_test_support::TestAppServer;+use app_test_support::write_chatgpt_auth;use app_test_support::write_models_cache_with_models;+use axum::Json;use axum::Router;+use axum::extract::State;+use axum::extract::ws::WebSocketUpgrade;+use axum::http::HeaderMap;+use axum::http::StatusCode;+use axum::response::IntoResponse;use axum::routing::get;use codex_app_server_protocol::ApprovalsReviewer;+use codex_app_server_protocol::CyberAccessProgram;use codex_app_server_protocol::ThreadStartParams;use codex_app_server_protocol::ThreadStartResponse;use codex_app_server_protocol::TurnCompletedNotification;@@ -19,9 +28,12 @@ use codex_app_server_protocol::TurnStartResponse;use codex_app_server_protocol::TurnStatus;use codex_app_server_protocol::UserInput;use codex_features::Feature;+use codex_login::AuthCredentialsStoreMode;use core_test_support::load_default_config_for_test;use core_test_support::skip_if_no_network;use pretty_assertions::assert_eq;+use serde_json::Value;+use serde_json::json;use tempfile::TempDir;use test_case::test_case;use tokio::net::TcpListener;@@ -29,11 +41,15 @@ use tokio::time::timeout;use super::MODEL;use super::MockResponsesState;+use super::TEST_SERVER_NAME;+use super::TEST_TOOL_NAME;use super::TIMEOUT;use super::USER_CONTEXT;use super::luna_websocket;use super::parent_response;+use super::start_mcp_server;use super::start_mcp_server_with_tools;+use super::wait_for_guardian_reviews;use super::wait_for_luna_request;#[test_case("node_repl"; "browser")]@@ -135,3 +151,246 @@ async fn computer_use_scoring_follows_model_review_requirement(responses_server.abort();Ok(())}++#[test_case("snapshot", 0.0; "snapshot low risk")]+#[test_case("snapshot", 1.0; "snapshot high risk")]+#[test_case("conversation", 0.0; "conversation low risk")]+#[test_case("conversation", 1.0; "conversation high risk")]+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn guardian_programs_follow_each_turn_without_changing_parent_selection(+ classifier_mode: &str,+ luna_score: f64,+) -> Result<()> {+ skip_if_no_network!(Ok(()));++ let state = Arc::new(MockResponsesState {+ mcp_tool_sequence: Some(&[TEST_TOOL_NAME]),+ gate_each_guardian_review: true,+ luna_score,+ ..Default::default()+ });+ let parent_requests = Arc::new(Mutex::new(Vec::<Value>::new()));+ let router = Router::new()+ .route(+ "/backend-api/codex/responses",+ get(+ |state: State<Arc<MockResponsesState>>,+ headers: HeaderMap,+ websocket: WebSocketUpgrade| async move {+ if headers+ .get("x-codex-guardian")+ .and_then(|value| value.to_str().ok())+ == Some("classifier")+ {+ luna_websocket(state, websocket).await.into_response()+ } else {+ StatusCode::UPGRADE_REQUIRED.into_response()+ }+ },+ )+ .post({+ let parent_requests = Arc::clone(&parent_requests);+ move |State(state): State<Arc<MockResponsesState>>, Json(request): Json<Value>| {+ let parent_requests = Arc::clone(&parent_requests);+ async move {+ if request["model"] == MODEL {+ parent_requests+ .lock()+ .expect("parent request lock")+ .push(request.clone());+ }+ parent_response(State(state), Json(request)).await+ }+ }+ }),+ )+ .with_state(Arc::clone(&state));+ let listener = TcpListener::bind("127.0.0.1:0").await?;+ let responses_url = format!("http://{}", listener.local_addr()?);+ let responses_server = tokio::spawn(async move {+ let _ = axum::serve(listener, router).await;+ });+ let (mcp_url, mcp_server) = start_mcp_server(/*sensitive_action*/ None).await?;+ let codex_home = TempDir::new()?;+ std::fs::write(+ codex_home.path().join("config.toml"),+ format!(+ r#"+model = "{MODEL}"+approval_policy = "on-request"+approvals_reviewer = "auto_review"+sandbox_mode = "read-only"+cli_auth_credentials_store = "file"+openai_base_url = "{responses_url}/backend-api/codex"+chatgpt_base_url = "{responses_url}/backend-api"++[features]+guardian_approval = true+enable_request_compression = false++[mcp_servers.{TEST_SERVER_NAME}]+url = "{mcp_url}/mcp"+default_tools_approval_mode = "prompt"++[features.guardianv2]+enabled = true+async_classifier_mode = "{classifier_mode}"++[features.guardianv2.review_scope]+computer_use_only = false+"#+ ),+ )?;+ write_chatgpt_auth(+ codex_home.path(),+ ChatGptAuthFixture::new("access-chatgpt").plan_type("pro"),+ AuthCredentialsStoreMode::File,+ )?;+ let config = load_default_config_for_test(&codex_home).await;+ let models = [MODEL, "gpt-5.6-luna", "gpt-6.1-sol"]+ .into_iter()+ .map(|slug| {+ let mut info = codex_core::test_support::construct_model_info_offline(slug, &config);+ if slug == MODEL {+ info.auto_review_model_override = Some("gpt-6.1-sol".to_owned());+ }+ info+ })+ .collect();+ write_models_cache_with_models(codex_home.path(), models).await?;+ let mut app_server = TestAppServer::builder()+ .with_codex_home(codex_home.path())+ .with_env_overrides(&[+ ("OPENAI_API_KEY", None),+ ("CODEX_API_KEY", None),+ ("CODEX_ACCESS_TOKEN", None),+ ("OPENAI_FEDERATION_RULE_ID", None),+ ("OPENAI_IDENTITY_TOKEN_FILE", None),+ ("OPENAI_WORKLOAD_IDENTITY_CONTEXT", None),+ ])+ .build_initialized_with_timeout(TIMEOUT)+ .await?;+ let thread = app_server+ .start_thread(ThreadStartParams::default())+ .await?+ .thread;+ let cases = [+ (+ Some(CyberAccessProgram::DaybreakBlue),+ Some("daybreak_blue"),+ Some("daybreak_blue"),+ ),+ (+ Some(CyberAccessProgram::DaybreakRed),+ Some("daybreak_red"),+ Some("daybreak_blue"),+ ),+ (+ Some(CyberAccessProgram::Standard),+ Some("standard"),+ Some("standard"),+ ),+ (None, None, None),+ ];+ let mut classifier_requests = Vec::new();+ for (index, (program, _, _)) in cases.iter().enumerate() {+ state.parent_requests.store(0, Ordering::SeqCst);+ app_server.clear_message_buffer();+ let request_id = app_server+ .send_turn_start_request(TurnStartParams {+ thread_id: thread.id.clone(),+ cyber_access_program: *program,+ input: vec![UserInput::Text {+ text: format!("{USER_CONTEXT} This is program turn {index}."),+ text_elements: Vec::new(),+ }],+ ..Default::default()+ })+ .await?;+ let _: TurnStartResponse = timeout(TIMEOUT, app_server.read_response(request_id)).await??;+ let classifier_request = wait_for_luna_request(&state, index).await?;+ assert!(+ classifier_request+ .to_string()+ .contains(&format!("program turn {index}"))+ );+ assert!(+ classifier_request.to_string().contains("program turn 0"),+ "prior turn evidence remains available after changing programs"+ );+ classifier_requests.push(classifier_request);+ // Wait for the reviewer to start before releasing a low classifier score.+ wait_for_guardian_reviews(&state, index + 1).await?;+ state.allow_luna.notify_one();+ state.allow_guardian_review.notify_one();+ let completed: TurnCompletedNotification =+ timeout(TIMEOUT, app_server.read_notification("turn/completed")).await??;+ assert_eq!(completed.turn.status, TurnStatus::Completed);+ }++ let expected_guardian_programs = cases+ .iter()+ .map(|(_, _, name)| name.map(|name| json!({"cyber": name})))+ .collect::<Vec<_>>();+ assert_eq!(+ classifier_requests+ .iter()+ .map(|request| (+ request["model"].clone(),+ request.get("access_programs").cloned()+ ))+ .collect::<Vec<_>>(),+ expected_guardian_programs+ .iter()+ .map(|program| (json!("gpt-5.6-luna"), program.clone()))+ .collect::<Vec<_>>()+ );+ let guardian_requests = state+ .guardian_requests+ .lock()+ .expect("Guardian request lock")+ .clone();+ assert_eq!(+ guardian_requests+ .iter()+ .map(|request| (+ request["model"].clone(),+ request.get("access_programs").cloned()+ ))+ .collect::<Vec<_>>(),+ expected_guardian_programs+ .iter()+ .map(|program| (json!("gpt-6.1-sol"), program.clone()))+ .collect::<Vec<_>>()+ );+ assert_eq!(+ parent_requests+ .lock()+ .expect("parent request lock")+ .iter()+ .map(|request| request.get("access_programs").cloned())+ .collect::<Vec<_>>(),+ cases+ .iter()+ .flat_map(|(_, name, _)| std::iter::repeat_n(+ name.map(|name| json!({"cyber": name})),+ 2+ ))+ .collect::<Vec<_>>()+ );+ let reviewer_thread_ids = guardian_requests+ .iter()+ .map(|request| request["client_metadata"]["thread_id"].clone())+ .collect::<Vec<_>>();+ assert!(reviewer_thread_ids[0].is_string());+ assert_eq!(+ reviewer_thread_ids,+ vec![reviewer_thread_ids[0].clone(); cases.len()],+ "program changes should reuse the reviewer session"+ );++ app_server.shutdown_gracefully().await?;+ mcp_server.abort();+ responses_server.abort();+ Ok(())+}diff --git a/codex-rs/core/src/cyber_access_program.rs b/codex-rs/core/src/cyber_access_program.rsindex 0b7803b7b1..bbc50b90c5 100644--- a/codex-rs/core/src/cyber_access_program.rs+++ b/codex-rs/core/src/cyber_access_program.rs@@ -8,15 +8,17 @@ use codex_protocol::error::CodexErr;use codex_protocol::error::Result;use codex_protocol::turn_input::CyberAccessProgram;+/// Configured support for explicit Cyber programs on API-key requests.#[derive(Clone, Copy, Debug)]-pub(crate) enum ApiKeyCyberAccessPrograms {+pub enum ApiKeyCyberAccessPrograms {UnsupportedProvider,Disabled,Enabled,}impl ApiKeyCyberAccessPrograms {- pub(crate) fn from_config(config: &crate::config::Config) -> Self {+ /// Captures the same provider and feature policy used by ordinary model requests.+ pub fn from_config(config: &crate::config::Config) -> Self {if config.model_provider_id != OPENAI_PROVIDER_ID {Self::UnsupportedProvider} else if config.features.enabled(Feature::ApiKeyCyberAccessPrograms) {@@ -34,7 +36,8 @@ pub(crate) fn for_provider(program.filter(|_| provider_id == OPENAI_PROVIDER_ID)}-pub(crate) fn for_auth(+/// Resolves an explicit program using the request's current authentication.+pub fn for_auth(auth: Option<&CodexAuth>,program: Option<CyberAccessProgram>,policy: ApiKeyCyberAccessPrograms,diff --git a/codex-rs/core/src/guardian/review_session.rs b/codex-rs/core/src/guardian/review_session.rsindex 80763c9db0..78ce4b6a5b 100644--- a/codex-rs/core/src/guardian/review_session.rs+++ b/codex-rs/core/src/guardian/review_session.rs@@ -759,6 +759,7 @@ async fn run_review_on_session(personality: params.personality,model: review_model.model.clone(),reasoning_effort: review_model.reasoning_effort.clone(),+ cyber_access_program: parent_turn.cyber_access_program,parent_response_id: params.parent_context.parent_response_id.clone(),schema: params.schema.clone(),parent_turn_id: parent_turn.sub_id.clone(),diff --git a/codex-rs/core/src/lib.rs b/codex-rs/core/src/lib.rsindex 56f64aeeb6..e59f841ef1 100644--- a/codex-rs/core/src/lib.rs+++ b/codex-rs/core/src/lib.rs@@ -86,7 +86,7 @@ pub mod connectors;pub mod context;mod context_manager;mod current_time;-mod cyber_access_program;+pub mod cyber_access_program;mod elicitation;mod environment_selection;pub mod exec;diff --git a/codex-rs/core/src/session/turn_context.rs b/codex-rs/core/src/session/turn_context.rsindex 1e705c88eb..40cf7657a6 100644--- a/codex-rs/core/src/session/turn_context.rs+++ b/codex-rs/core/src/session/turn_context.rs@@ -1374,6 +1374,10 @@ impl Session {&turn_context.config.model_provider_id,options.cyber_access_program,);+ // Tool observers retain this turn's selection even after a later turn starts.+ if let Some(program) = turn_context.cyber_access_program {+ turn_context.extension_data.insert(program);+ }let turn_context = Arc::new(turn_context);if git_enrichment_policy == GitEnrichmentPolicy::Fresh&& turn_contextdiff --git a/codex-rs/core/tests/suite/guardian_cyber_access_program_tests.rs b/codex-rs/core/tests/suite/guardian_cyber_access_program_tests.rsnew file mode 100644index 0000000000..f8d5d88556--- /dev/null+++ b/codex-rs/core/tests/suite/guardian_cyber_access_program_tests.rs@@ -0,0 +1,179 @@+//! Verifies that reused Guardian reviewers use Blue for Daybreak without changing parent programs.++use anyhow::Result;+use codex_core::TurnInputRequest;+use codex_core::TurnStartOptions;+use codex_core::config::Constrained;+use codex_features::Feature;+use codex_login::CodexAuth;+use codex_protocol::approvals::GuardianAssessmentStatus;+use codex_protocol::config_types::ApprovalsReviewer;+use codex_protocol::protocol::AskForApproval;+use codex_protocol::protocol::EventMsg;+use codex_protocol::protocol::SandboxPolicy;+use codex_protocol::turn_input::CyberAccessProgram;+use codex_protocol::user_input::UserInput;+use core_test_support::responses;+use core_test_support::skip_if_no_network;+use core_test_support::skip_if_wine_exec;+use core_test_support::test_codex::test_codex;+use pretty_assertions::assert_eq;+use serde_json::json;+use test_case::test_case;++#[test_case(CodexAuth::from_api_key("test-api-key"); "api_key")]+#[test_case(CodexAuth::create_dummy_chatgpt_auth_for_testing(); "chatgpt")]+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn guardian_reused_reviewer_uses_blue_without_changing_parent_cyber_access_program(+ auth: CodexAuth,+) -> Result<()> {+ skip_if_no_network!(Ok(()));+ skip_if_wine_exec!(+ Ok(()),+ "Guardian approval actions require host-native paths"+ );++ let server = responses::start_mock_server().await;+ let test = test_codex()+ .with_auth(auth)+ .with_model_info_override("gpt-6.1-sol", |_| {})+ .with_model_info_override("gpt-5.5", |model| {+ model.guardian = None;+ model.auto_review_model_override = Some("gpt-6.1-sol".to_owned());+ })+ .with_config(|config| {+ config.permissions.approval_policy = Constrained::allow_any(AskForApproval::OnRequest);+ config.approvals_reviewer = ApprovalsReviewer::AutoReview;+ config+ .set_legacy_sandbox_policy(SandboxPolicy::new_workspace_write_policy())+ .expect("set sandbox policy");+ config+ .features+ .enable(Feature::ApiKeyCyberAccessPrograms)+ .expect("enable API-key Cyber access programs");+ })+ .build_with_auto_env(&server)+ .await?;++ let cases = [+ (+ Some(CyberAccessProgram::DaybreakBlue),+ Some("daybreak_blue"),+ ),+ (Some(CyberAccessProgram::DaybreakRed), Some("daybreak_red")),+ (Some(CyberAccessProgram::Standard), Some("standard")),+ (None, None),+ ];+ let mut events = Vec::new();+ for (index, _) in cases.iter().enumerate() {+ events.push(responses::sse(vec![+ responses::ev_function_call(+ &format!("command-{index}"),+ "exec_command",+ &json!({+ "cmd": format!("echo guardian-program-{index}"),+ "sandbox_permissions": "require_escalated",+ "justification": "Run the requested command.",+ })+ .to_string(),+ ),+ responses::ev_completed(&format!("parent-call-{index}")),+ ]));+ events.push(responses::sse(vec![+ responses::ev_assistant_message(+ &format!("approval-{index}"),+ r#"{"risk_level":"low","user_authorization":"high","outcome":"allow","rationale":"requested command"}"#,+ ),+ responses::ev_completed(&format!("review-{index}")),+ ]));+ events.push(responses::sse(vec![responses::ev_completed(&format!(+ "parent-done-{index}"+ ))]));+ }+ let requests = responses::mount_sse_sequence(&server, events).await;++ for (index, (program, _)) in cases.iter().enumerate() {+ test.codex+ .start_or_steer_turn(+ TurnInputRequest::user_input(vec![UserInput::Text {+ text: format!("Run echo guardian-program-{index}."),+ text_elements: Vec::new(),+ }])+ .on_start(TurnStartOptions {+ cyber_access_program: *program,+ ..Default::default()+ }),+ )+ .await?;+ let mut assessments = Vec::new();+ loop {+ match test.codex.next_event().await?.msg {+ EventMsg::GuardianAssessment(assessment) => assessments.push(assessment.status),+ EventMsg::TurnComplete(_) => break,+ _ => {}+ }+ }+ assert_eq!(+ assessments,+ vec![+ GuardianAssessmentStatus::InProgress,+ GuardianAssessmentStatus::Approved,+ ]+ );+ }++ let requests = requests.requests();+ let (guardian_requests, parent_requests): (Vec<_>, Vec<_>) = requests+ .iter()+ .map(responses::ResponsesRequest::body_json)+ .partition(|body| body["client_metadata"]["x-openai-subagent"] == "guardian");+ let expected_parent_programs = cases+ .iter()+ .map(|(_, name)| name.map(|name| json!({ "cyber": name })))+ .collect::<Vec<_>>();+ let expected_guardian_programs = [+ Some(json!({ "cyber": "daybreak_blue" })),+ Some(json!({ "cyber": "daybreak_blue" })),+ Some(json!({ "cyber": "standard" })),+ None,+ ];+ assert_eq!(+ guardian_requests+ .iter()+ .map(|body| (+ body["model"].clone(),+ body["reasoning"]["effort"].clone(),+ body.get("access_programs").cloned(),+ ))+ .collect::<Vec<_>>(),+ expected_guardian_programs+ .iter()+ .map(|program| (json!("gpt-6.1-sol"), json!("low"), program.clone()))+ .collect::<Vec<_>>()+ );+ assert_eq!(+ parent_requests+ .iter()+ .map(|body| (body["model"].clone(), body.get("access_programs").cloned()))+ .collect::<Vec<_>>(),+ expected_parent_programs+ .iter()+ .flat_map(|program| std::iter::repeat_n((json!("gpt-5.5"), program.clone()), 2))+ .collect::<Vec<_>>()+ );+ let reviewer_thread_ids = guardian_requests+ .iter()+ .map(|body| {+ body["client_metadata"]["thread_id"]+ .as_str()+ .expect("Guardian request should have a thread id")+ })+ .collect::<Vec<_>>();+ assert_eq!(+ reviewer_thread_ids,+ vec![reviewer_thread_ids[0]; cases.len()],+ "program changes should reuse the reviewer session"+ );+ test.codex.shutdown_and_wait().await?;+ Ok(())+}diff --git a/codex-rs/core/tests/suite/mod.rs b/codex-rs/core/tests/suite/mod.rsindex 750fd59520..d1acfc3bfd 100644--- a/codex-rs/core/tests/suite/mod.rs+++ b/codex-rs/core/tests/suite/mod.rs@@ -100,6 +100,8 @@ mod gateway_auth;mod guardian_connector_trust;#[cfg(not(target_os = "windows"))]mod guardian_context_budget;+#[path = "guardian_cyber_access_program_tests.rs"]+mod guardian_cyber_access_program;mod guardian_history;mod guardian_mcp_elicitation;#[cfg(not(target_os = "windows"))]diff --git a/codex-rs/ext/guardian-reviewer/src/lib.rs b/codex-rs/ext/guardian-reviewer/src/lib.rsindex 8655a43669..173401024a 100644--- a/codex-rs/ext/guardian-reviewer/src/lib.rs+++ b/codex-rs/ext/guardian-reviewer/src/lib.rs@@ -59,6 +59,7 @@ pub use execution::start_review_turn;pub use execution::wait_for_guardian_review;pub use settings::ReviewerConfig;pub use settings::ReviewerTurn;+pub use settings::guardian_cyber_access_program;pub use settings::reviewer_permission_profile;pub use settings::reviewer_tool_policy;diff --git a/codex-rs/ext/guardian-reviewer/src/settings.rs b/codex-rs/ext/guardian-reviewer/src/settings.rsindex a504b4dc26..2a2fa0aeb1 100644--- a/codex-rs/ext/guardian-reviewer/src/settings.rs+++ b/codex-rs/ext/guardian-reviewer/src/settings.rs@@ -17,6 +17,7 @@ use codex_protocol::protocol::AskForApproval;use codex_protocol::protocol::EnvironmentConfigState;use codex_protocol::protocol::ThreadSettingsOverrides;use codex_protocol::protocol::TurnEnvironmentSelections;+use codex_protocol::turn_input::CyberAccessProgram;use codex_protocol::turn_input::TurnInputRequest;use codex_protocol::turn_input::TurnStartOptions;use codex_protocol::user_input::UserInput;@@ -27,6 +28,18 @@ use serde_json::Value;/// Keeping it in thread data avoids caching settings that can change between reviews.pub struct ReviewerConfig<C>(pub fn(&C) -> anyhow::Result<C>);+/// Uses Blue for either Daybreak selection without changing Standard or automatic behavior.+pub fn guardian_cyber_access_program(+ program: Option<CyberAccessProgram>,+) -> Option<CyberAccessProgram> {+ program.map(|program| match program {+ CyberAccessProgram::Standard => CyberAccessProgram::Standard,+ CyberAccessProgram::DaybreakBlue | CyberAccessProgram::DaybreakRed => {+ CyberAccessProgram::DaybreakBlue+ }+ })+}+/// Reviewer tool selection and construction restrictions, enforced by core.pub fn reviewer_tool_policy() -> ToolPolicy {ToolPolicy {@@ -60,6 +73,8 @@ pub struct ReviewerTurn {pub personality: Option<Personality>,pub model: String,pub reasoning_effort: Option<ReasoningEffort>,+ /// The parent turn's selection; Guardian uses Blue for either Daybreak program.+ pub cyber_access_program: Option<CyberAccessProgram>,pub parent_response_id: Option<String>,pub schema: Value,pub parent_turn_id: String,@@ -99,6 +114,7 @@ impl ReviewerTurn {).on_start(TurnStartOptions {turn_trigger: Some("guardian_review".to_owned()),+ cyber_access_program: guardian_cyber_access_program(self.cyber_access_program),final_output_json_schema: Some(self.schema),parent_turn_id: Some(self.parent_turn_id),root_turn_id: self.root_turn_id,diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/classification.rs b/codex-rs/ext/guardian-v2/src/async_scorer/classification.rsindex 08d68d4ff0..18e7789af7 100644--- a/codex-rs/ext/guardian-v2/src/async_scorer/classification.rs+++ b/codex-rs/ext/guardian-v2/src/async_scorer/classification.rs@@ -36,6 +36,7 @@ use codex_prompts::ResolvedModelMessages;use codex_protocol::models::ContentItem;use codex_protocol::openai_models::ModelInfo;use codex_protocol::security_risk::SecurityRiskScore;+use codex_protocol::turn_input::CyberAccessProgram;use super::authorization::ScoreAuthorization;use super::config::GuardianV2Config;@@ -71,6 +72,7 @@ pub(super) struct Classification {pub(super) thread_id: String,pub(super) turn_id: String,pub(super) root_turn_id: Option<String>,+ pub(super) cyber_access_program: Option<CyberAccessProgram>,pub(super) parent_response_id: Option<String>,pub(super) manager: Arc<ThreadManager>,pub(super) thread: Arc<CodexThread>,@@ -136,6 +138,7 @@ impl Classification {thread_id,turn_id,root_turn_id,+ cyber_access_program,parent_response_id,manager,thread,@@ -312,6 +315,7 @@ impl Classification {let extra_policy = config.guardian_extra_policy.as_deref().unwrap_or_default();let instructions = guardian_config.render_classifier_instructions(policy, extra_policy);let mut sampling = LunaSamplingRequest {+ cyber_access_program,parent_response_id,instructions,input: Vec::new(),diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/observation.rs b/codex-rs/ext/guardian-v2/src/async_scorer/observation.rsindex e1eaf45d14..61d81e3a2a 100644--- a/codex-rs/ext/guardian-v2/src/async_scorer/observation.rs+++ b/codex-rs/ext/guardian-v2/src/async_scorer/observation.rs@@ -20,6 +20,7 @@ use codex_protocol::mcp::is_node_repl_backed_connector;use codex_protocol::openai_models::GuardianReviewMode;use codex_protocol::openai_models::GuardianScope;use codex_protocol::openai_models::ModelInfo;+use codex_protocol::turn_input::CyberAccessProgram;use super::action::ActionRenderError;use super::action::GuardianAction;@@ -161,6 +162,10 @@ impl GuardianV2Extension {let thread_id = input.thread_store.level_id().to_owned();let turn_id = input.turn_id.to_owned();let root_turn_id = input.root_turn_id.map(str::to_owned);+ let cyber_access_program = input+ .turn_store+ .get::<CyberAccessProgram>()+ .map(|program| *program);let parent_response_id = input.turn_store.get::<codex_api::ResponseId>()@@ -380,6 +385,7 @@ impl GuardianV2Extension {thread_id,turn_id,root_turn_id,+ cyber_access_program,parent_response_id,manager,thread,diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/sampler.rs b/codex-rs/ext/guardian-v2/src/async_scorer/sampler.rsindex 13111d0a46..9f97141cdf 100644--- a/codex-rs/ext/guardian-v2/src/async_scorer/sampler.rs+++ b/codex-rs/ext/guardian-v2/src/async_scorer/sampler.rs@@ -17,6 +17,7 @@ use codex_api::Reasoning;use codex_api::ReasoningContext;use codex_api::ResponsesApiRequest;use codex_context_fragments::RenderedFragment;+use codex_core::cyber_access_program::ApiKeyCyberAccessPrograms;use codex_extension_api::ExtensionMetrics;use codex_history::ResponseItemEnvelope;use codex_http_client::HttpClientFactory;@@ -29,6 +30,7 @@ use codex_protocol::models::ContentItem;use codex_protocol::models::ResponseItem;use codex_protocol::openai_models::ReasoningEffort;use codex_protocol::protocol::SessionSource;+use codex_protocol::turn_input::CyberAccessProgram;use thiserror::Error;use tokio::sync::oneshot;use uuid::Uuid;@@ -44,6 +46,8 @@ const MAX_CONCURRENT_REQUESTS: usize = 16;pub struct LunaSamplerConfig {/// Provider and credentials selected for the owning thread.pub provider: SharedModelProvider,+ /// Provider and feature policy shared with ordinary model requests.+ pub api_key_cyber_access_programs: ApiKeyCyberAccessPrograms,/// Routing scope and retained configuration layers for the owning thread.pub workspace_routing: WorkspaceRoutingContext,/// Effective proxy, custom-CA, and cookie configuration.@@ -70,6 +74,8 @@ pub struct LunaSamplerConfig {/// One tool-less Luna classification request.pub struct LunaSamplingRequest {+ /// Cyber selection captured from the owning turn; Daybreak reviews use Blue.+ pub cyber_access_program: Option<CyberAccessProgram>,/// ID of the response handling the classified tool.pub parent_response_id: Option<String>,/// Trusted classifier instructions with their role and content attribution.@@ -246,6 +252,9 @@ impl LunaSampler {};execution::SamplingExecution {auth_owner_generation,+ cyber_access_program: codex_guardian_reviewer::guardian_cyber_access_program(+ request.cyber_access_program,+ ),config: Arc::clone(&self.config),connections: Arc::clone(&self.connections),request: api_request,diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/sampler/execution.rs b/codex-rs/ext/guardian-v2/src/async_scorer/sampler/execution.rsindex 2affc8c3df..bc6c6065b7 100644--- a/codex-rs/ext/guardian-v2/src/async_scorer/sampler/execution.rs+++ b/codex-rs/ext/guardian-v2/src/async_scorer/sampler/execution.rs@@ -13,11 +13,13 @@ use codex_api::ApiError;use codex_api::ResponseEvent;use codex_api::ResponsesApiRequest;use codex_api::TransportError;+use codex_core::cyber_access_program;use codex_extension_api::ExtensionMetrics;use codex_login::UnauthorizedRecovery;use codex_protocol::models::ContentItem;use codex_protocol::models::ResponseItem;use codex_protocol::protocol::TokenUsage;+use codex_protocol::turn_input::CyberAccessProgram;use http::StatusCode;use serde_json::json;use std::collections::HashMap;@@ -33,6 +35,7 @@ const TURN_METADATA_KEY: &str = "x-codex-turn-metadata";pub(super) struct SamplingExecution {pub(super) auth_owner_generation: Option<u64>,+ pub(super) cyber_access_program: Option<CyberAccessProgram>,pub(super) config: Arc<LunaSamplerConfig>,pub(super) connections: Arc<ConnectionPool>,pub(super) request: ResponsesApiRequest,@@ -257,6 +260,24 @@ impl SamplingExecution {return Err(error);}};+ // Omitted programs need no auth lookup, which can refresh credentials.+ self.request.access_programs = match self.cyber_access_program {+ None => None,+ Some(program) => {+ let auth = tokio::select! {+ biased;+ _ = &mut owner_changed => return Err(account_changed_error()),+ _ = mode.superseded() => return Err(LunaSamplerError::Superseded),+ auth = self.config.provider.auth() => auth,+ };+ cyber_access_program::for_auth(+ auth.as_ref(),+ Some(program),+ self.config.api_key_cyber_access_programs,+ )+ .map_err(LunaSamplerError::Provider)?+ }+ };ensure_account_owner()?;self.request.service_tier = if lease.request_kind == RequestMode::GuardianClassifier {Nonediff --git a/codex-rs/ext/guardian-v2/src/async_scorer/sampler_tests.rs b/codex-rs/ext/guardian-v2/src/async_scorer/sampler_tests.rsindex 53397c38db..4de2c769c8 100644--- a/codex-rs/ext/guardian-v2/src/async_scorer/sampler_tests.rs+++ b/codex-rs/ext/guardian-v2/src/async_scorer/sampler_tests.rs@@ -1,6 +1,7 @@use anyhow::Result;use codex_api::ApiError;use codex_context_fragments::RenderedFragment;+use codex_core::cyber_access_program::ApiKeyCyberAccessPrograms;use codex_extension_api::ContextualUserFragment;use codex_extension_api::ExtensionMetrics;use codex_guardian_context::PreviousReviews;@@ -22,6 +23,7 @@ use codex_protocol::models::ContentItem;use codex_protocol::models::ResponseItem;use codex_protocol::openai_models::ReasoningEffort;use codex_protocol::protocol::SessionSource;+use codex_protocol::turn_input::CyberAccessProgram;use core_test_support::responses;use core_test_support::responses::WebSocketConnectionConfig;use core_test_support::responses::ev_assistant_message;@@ -204,6 +206,7 @@ pub(in crate::async_scorer) async fn proxy_websocket_servers_with_http(pub(in crate::async_scorer) fn sampler_config(base_url: String) -> LunaSamplerConfig {LunaSamplerConfig {+ api_key_cyber_access_programs: ApiKeyCyberAccessPrograms::Disabled,workspace_routing: codex_model_provider::WorkspaceRoutingContext::new("https://chatgpt.com/backend-api".into(),),@@ -265,6 +268,7 @@ fn assert_classifier_instructions(request: &serde_json::Value) {pub(in crate::async_scorer) fn sample_request(parent_turn_id: &str) -> LunaSamplingRequest {LunaSamplingRequest {+ cyber_access_program: None,parent_response_id: None,instructions: classifier_instructions(),input: vec![responses::user_message_item(@@ -278,6 +282,60 @@ pub(in crate::async_scorer) fn sample_request(parent_turn_id: &str) -> LunaSampl}}+#[tokio::test]+async fn classifier_preserves_api_key_cyber_program_policy() -> Result<()> {+ skip_if_no_network!(Ok(()));+ for policy in [+ ApiKeyCyberAccessPrograms::Enabled,+ ApiKeyCyberAccessPrograms::Disabled,+ ApiKeyCyberAccessPrograms::UnsupportedProvider,+ ] {+ let server = responses::start_mock_server().await;+ let response = responses::mount_sse_once(+ &server,+ responses::sse(vec![+ ev_assistant_message("score", "low"),+ ev_completed("score"),+ ]),+ )+ .await;+ let mut config = sampler_config(server.uri());+ config.api_key_cyber_access_programs = policy;+ let sampler = LunaSampler::new(config);+ let mut request = sample_request("parent");+ request.cyber_access_program = Some(CyberAccessProgram::DaybreakRed);+ let result = sampler.sample(request).await;+ match policy {+ ApiKeyCyberAccessPrograms::Disabled => {+ assert!(+ result+ .unwrap_err()+ .to_string()+ .contains("Cyber access programs are disabled for this API-key session.")+ );+ assert!(response.requests().is_empty());+ }+ ApiKeyCyberAccessPrograms::Enabled | ApiKeyCyberAccessPrograms::UnsupportedProvider => {+ assert_eq!(result?, "low");+ let expected = match policy {+ ApiKeyCyberAccessPrograms::Enabled => Some(json!({"cyber": "daybreak_blue"})),+ ApiKeyCyberAccessPrograms::UnsupportedProvider => None,+ ApiKeyCyberAccessPrograms::Disabled => unreachable!(),+ };+ assert_eq!(+ response+ .single_request()+ .body_json()+ .get("access_programs")+ .cloned(),+ expected,+ );+ }+ }+ }+ Ok(())+}+type RecordedMetric = (String, i64, Vec<(String, String)>);#[derive(Default)]@@ -518,6 +576,7 @@ async fn preconnected_sampler_reuses_authenticated_websocket_for_classifications);let sampler = connect_sampler(LunaSamplerConfig {+ api_key_cyber_access_programs: ApiKeyCyberAccessPrograms::Disabled,workspace_routing: codex_model_provider::WorkspaceRoutingContext::new("https://chatgpt.com/backend-api".into(),),@@ -564,6 +623,7 @@ async fn preconnected_sampler_reuses_authenticated_websocket_for_classificationslet first = sampler.sample(LunaSamplingRequest {+ cyber_access_program: None,parent_response_id: None,instructions: classifier_instructions(),input: vec![ResponseItem::Message {@@ -607,6 +667,7 @@ async fn preconnected_sampler_reuses_authenticated_websocket_for_classificationssampler.prewarm().await;let second = sampler.sample(LunaSamplingRequest {+ cyber_access_program: None,parent_response_id: None,instructions: classifier_instructions(),input: vec![responses::user_message_item(@@ -779,6 +840,7 @@ async fn sampler_returns_classification_token_before_terminal_response_events()))),);let sampler = connect_sampler(LunaSamplerConfig {+ api_key_cyber_access_programs: ApiKeyCyberAccessPrograms::Disabled,workspace_routing: codex_model_provider::WorkspaceRoutingContext::new("https://chatgpt.com/backend-api".into(),),@@ -800,6 +862,7 @@ async fn sampler_returns_classification_token_before_terminal_response_events()let output = tokio::time::timeout(Duration::from_secs(2),sampler.sample(LunaSamplingRequest {+ cyber_access_program: None,parent_response_id: None,instructions: classifier_instructions(),input: vec![responses::user_message_item(diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/startup.rs b/codex-rs/ext/guardian-v2/src/async_scorer/startup.rsindex cf3cef56ea..e7a1b300c2 100644--- a/codex-rs/ext/guardian-v2/src/async_scorer/startup.rs+++ b/codex-rs/ext/guardian-v2/src/async_scorer/startup.rs@@ -5,6 +5,7 @@ use std::sync::Arc;use codex_core::ThreadManager;use codex_core::config::Config;+use codex_core::cyber_access_program::ApiKeyCyberAccessPrograms;use codex_extension_api::ThreadOriginator;use codex_extension_api::ThreadStartInput;use codex_features::Feature;@@ -92,6 +93,7 @@ pub(super) async fn sampler_config(});let luna_compaction_hash = luna_model.and_then(|model| model.comp_hash);LunaSamplerConfig {+ api_key_cyber_access_programs: ApiKeyCyberAccessPrograms::from_config(input.config),workspace_routing: input.thread_store.get_or_init(|| input.config.workspace_routing_context())