Skip to content

armgit / codex

Public Imported from GitHub
0

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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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_context
diff --git a/codex-rs/core/tests/suite/guardian_cyber_access_program_tests.rs b/codex-rs/core/tests/suite/guardian_cyber_access_program_tests.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 {
None
diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/sampler_tests.rs b/codex-rs/ext/guardian-v2/src/async_scorer/sampler_tests.rs
index 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_classifications
let 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_classifications
sampler.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.rs
index 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())