Lightweight coding agent that runs in your terminal
Rust
Add per-turn Cyber access program selection to exec and the SDK (#49939)
mldangelo-oai6b4daafdb445
diff --git a/codex-rs/cli/src/exec_args_tests.rs b/codex-rs/cli/src/exec_args_tests.rsnew file mode 100644index 0000000000..c828bc4f4c--- /dev/null+++ b/codex-rs/cli/src/exec_args_tests.rs@@ -0,0 +1,30 @@+//! Snapshot coverage for the public exec command's argument help.++use super::MultitoolCli;+use clap::CommandFactory;+use pretty_assertions::assert_eq;++#[test]+fn exec_help_documents_cyber_access_program() {+ let help = MultitoolCli::command()+ .term_width(80)+ .try_get_matches_from(["codex", "exec", "--help"])+ .expect_err("help should short-circuit");+ assert_eq!(help.kind(), clap::error::ErrorKind::DisplayHelp);+ let program_help = help+ .to_string()+ .lines()+ .skip_while(|line| !line.contains("--cyber-access-program"))+ .take_while(|line| !line.is_empty())+ .map(str::trim_end)+ .collect::<Vec<_>>()+ .join("\n");+ insta::assert_snapshot!(program_help.trim(), @r"+ --cyber-access-program <PROGRAM>+ Request an experimental Cyber access program for this turn (OpenAI+ provider only). Omit to use server defaults. Not supported with+ review; fork requires a prompt++ [possible values: standard, daybreak_blue, daybreak_red]+ ");+}diff --git a/codex-rs/cli/src/main.rs b/codex-rs/cli/src/main.rsindex bdd7771b3a..ac06a665e0 100644--- a/codex-rs/cli/src/main.rs+++ b/codex-rs/cli/src/main.rs@@ -59,6 +59,9 @@ mod daemon_telemetry;mod desktop_app;mod doctor;#[cfg(test)]+#[path = "exec_args_tests.rs"]+mod exec_args_tests;+#[cfg(test)]#[path = "exec_server_args_tests.rs"]mod exec_server_args_tests;mod exec_server_auth;diff --git a/codex-rs/core/src/cyber_access_program.rs b/codex-rs/core/src/cyber_access_program.rsindex f71fee3e73..0b7803b7b1 100644--- a/codex-rs/core/src/cyber_access_program.rs+++ b/codex-rs/core/src/cyber_access_program.rs@@ -3,6 +3,7 @@use codex_api::AccessPrograms;use codex_features::Feature;use codex_login::CodexAuth;+use codex_model_provider_info::OPENAI_PROVIDER_ID;use codex_protocol::error::CodexErr;use codex_protocol::error::Result;use codex_protocol::turn_input::CyberAccessProgram;@@ -16,7 +17,7 @@ pub(crate) enum ApiKeyCyberAccessPrograms {impl ApiKeyCyberAccessPrograms {pub(crate) fn from_config(config: &crate::config::Config) -> Self {- if config.model_provider_id != codex_model_provider_info::OPENAI_PROVIDER_ID {+ if config.model_provider_id != OPENAI_PROVIDER_ID {Self::UnsupportedProvider} else if config.features.enabled(Feature::ApiKeyCyberAccessPrograms) {Self::Enabled@@ -26,6 +27,13 @@ impl ApiKeyCyberAccessPrograms {}}+pub(crate) fn for_provider(+ provider_id: &str,+ program: Option<CyberAccessProgram>,+) -> Option<CyberAccessProgram> {+ program.filter(|_| provider_id == OPENAI_PROVIDER_ID)+}+pub(crate) fn for_auth(auth: Option<&CodexAuth>,program: Option<CyberAccessProgram>,diff --git a/codex-rs/core/src/session/turn.rs b/codex-rs/core/src/session/turn.rsindex 106e2c4dd4..f13e98ccb0 100644--- a/codex-rs/core/src/session/turn.rs+++ b/codex-rs/core/src/session/turn.rs@@ -12,6 +12,7 @@ use crate::compact_remote_v2::run_inline_remote_auto_compact_task as run_inline_use crate::connectors;use crate::context::ContextualUserFragment;use crate::context::UserVerificationNotice;+use crate::cyber_access_program;use crate::environment_selection::TurnEnvironmentSnapshot;use crate::feedback_tags;use crate::hook_runtime::drain_async_hook_results;@@ -1335,21 +1336,23 @@ fn comp_hash_changed(previous: Option<&str>, current: Option<&str>) -> bool {/// Captures the current model's request-scoped state for retrying previous-model compaction.///-/// Returns `None` when the active authentication does not use the Codex backend, the provider is-/// not OpenAI, or the previous and current model are the same.+/// Returns `None` when auth uses neither the Codex backend nor an API key, the provider is+/// not OpenAI, or the previous and current model/program pairs are the same.async fn capture_current_model_fallback_step_context(sess: &Arc<Session>,turn_context: &Arc<TurnContext>,- previous_model: &str,+ previous_turn_context: &TurnContext,cancellation_token: &CancellationToken,) -> CodexResult<Option<Arc<StepContext>>> {- let uses_codex_backend = turn_context+ let supports_fallback = turn_context.auth_manager.as_deref()- .is_some_and(codex_login::AuthManager::current_auth_uses_codex_backend);- if !uses_codex_backend+ .and_then(codex_login::AuthManager::auth_cached)+ .is_some_and(|auth| auth.uses_codex_backend() || auth.is_api_key_auth());+ if !supports_fallback|| !turn_context.provider.info().is_openai()- || previous_model == turn_context.model_info().slug+ || (previous_turn_context.model_info().slug == turn_context.model_info().slug+ && previous_turn_context.cyber_access_program == turn_context.cyber_access_program){return Ok(None);}@@ -1386,7 +1389,10 @@ async fn maybe_run_previous_model_inline_compact(// turn's program so compaction uses the same model/cyber_access_program pair as that turn.// Combining the previous model with the current turn's program can produce a pair// that the server rejects.- previous_model_turn_context.cyber_access_program = previous_turn_settings.cyber_access_program;+ previous_model_turn_context.cyber_access_program = cyber_access_program::for_provider(+ &previous_model_turn_context.config.model_provider_id,+ previous_turn_settings.cyber_access_program,+ );let previous_model_turn_context = Arc::new(previous_model_turn_context);if should_compact_for_comp_hash_change {@@ -1396,7 +1402,7 @@ async fn maybe_run_previous_model_inline_compact(let fallback_step_context = capture_current_model_fallback_step_context(sess,turn_context,- previous_model.as_str(),+ &previous_model_turn_context,cancellation_token,).await?;@@ -1444,7 +1450,7 @@ async fn maybe_run_previous_model_inline_compact(let fallback_step_context = capture_current_model_fallback_step_context(sess,turn_context,- previous_model.as_str(),+ &previous_model_turn_context,cancellation_token,).await?;diff --git a/codex-rs/core/src/session/turn_context.rs b/codex-rs/core/src/session/turn_context.rsindex 8f94f0b81b..4db28491b2 100644--- a/codex-rs/core/src/session/turn_context.rs+++ b/codex-rs/core/src/session/turn_context.rs@@ -3,6 +3,7 @@ use super::token_budget::has_explicit_settings;use super::token_budget::resolve_token_budget;use super::*;use crate::config::TokenBudgetConfig;+use crate::cyber_access_program;use crate::environment_selection::EnvironmentConfigOrigin;use crate::environment_selection::TurnEnvironmentSnapshot;use crate::exec_policy::AllowPrefixRules;@@ -1439,9 +1440,10 @@ impl Session {turn_context.realtime_active = self.conversation.running_state().await.is_some();turn_context.final_output_json_schema = options.final_output_json_schema;- if turn_context.config.model_provider_id == codex_model_provider_info::OPENAI_PROVIDER_ID {- turn_context.cyber_access_program = options.cyber_access_program;- }+ turn_context.cyber_access_program = cyber_access_program::for_provider(+ &turn_context.config.model_provider_id,+ options.cyber_access_program,+ );let turn_context = Arc::new(turn_context);if git_enrichment_policy == GitEnrichmentPolicy::Fresh&& turn_contextdiff --git a/codex-rs/core/tests/suite/compact.rs b/codex-rs/core/tests/suite/compact.rsindex 6549a92c8f..08a9df5d9b 100644--- a/codex-rs/core/tests/suite/compact.rs+++ b/codex-rs/core/tests/suite/compact.rs@@ -2853,8 +2853,12 @@ async fn pre_sampling_compact_falls_back_when_previous_model_is_not_found() {);}+#[test_case::test_case("openai"; "built in provider")]+#[test_case::test_case("local"; "cloud agent provider alias")]#[tokio::test(flavor = "multi_thread", worker_threads = 2)]-async fn pre_sampling_compact_falls_back_after_previous_model_invalid_request_on_downshift() {+async fn pre_sampling_compact_falls_back_after_previous_model_invalid_request_on_downshift(+ provider_id: &'static str,+) {skip_if_no_network!();let server = MockServer::start().await;@@ -2909,11 +2913,15 @@ async fn pre_sampling_compact_falls_back_after_previous_model_invalid_request_on.with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing()).with_model(retired_model).with_config(move |config| {+ config.model_provider_id = provider_id.to_owned();config.model_provider = model_provider;config.tool_registry.turn_metadata_includes_tool_info = true;set_test_compact_prompt(config);});- let test = builder.build(&server).await.expect("build test codex");+ let test = builder+ .build_with_auto_env(&server)+ .await+ .expect("build test codex");test.codex.start_or_steer_turn(disabled_permission_user_turn(diff --git a/codex-rs/core/tests/suite/compact_program_tests.rs b/codex-rs/core/tests/suite/compact_program_tests.rsindex 3a357df410..808fffe145 100644--- a/codex-rs/core/tests/suite/compact_program_tests.rs+++ b/codex-rs/core/tests/suite/compact_program_tests.rs@@ -8,6 +8,7 @@ use codex_core::TurnStartOptions;use codex_protocol::turn_input::CyberAccessProgram;use pretty_assertions::assert_eq;use test_case::test_case;+use wiremock::ResponseTemplate;#[derive(Clone, Copy, Debug)]enum History {@@ -18,6 +19,8 @@ enum History {IncompleteRollback,Checkpoint,ApiKeyResume,+ ApiKeyEnabledResume,+ ApiKeyCustomProviderResume,}#[derive(Clone, Copy, Debug)]@@ -73,7 +76,11 @@ async fn submit_pair(#[test_case(Compaction::RemoteHash, History::Resume, Some(CyberAccessProgram::Standard); "standard")]#[test_case(Compaction::LocalHash, History::Live, None; "local missing program")]#[test_case(Compaction::Fallback, History::Live, Some(CyberAccessProgram::DaybreakBlue); "fallback")]-#[test_case(Compaction::LocalHash, History::ApiKeyResume, Some(CyberAccessProgram::DaybreakBlue); "api key cannot inherit authorization")]+#[test_case(Compaction::LocalHash, History::ApiKeyResume, Some(CyberAccessProgram::DaybreakBlue); "api key requires rollout features")]+#[test_case(Compaction::LocalHash, History::ApiKeyEnabledResume, Some(CyberAccessProgram::DaybreakBlue); "api key local resume")]+#[test_case(Compaction::RemoteHash, History::ApiKeyEnabledResume, Some(CyberAccessProgram::DaybreakBlue); "api key remote resume")]+#[test_case(Compaction::LocalHash, History::ApiKeyCustomProviderResume, Some(CyberAccessProgram::DaybreakBlue); "api key custom provider local resume")]+#[test_case(Compaction::RemoteHash, History::ApiKeyCustomProviderResume, Some(CyberAccessProgram::DaybreakBlue); "api key custom provider remote resume")]#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn model_switch_program_pair(compaction: Compaction,@@ -204,7 +211,9 @@ async fn model_switch_program_pair(| History::Rollback| History::IncompleteRollback| History::Checkpoint- | History::ApiKeyResume => {+ | History::ApiKeyResume+ | History::ApiKeyEnabledResume+ | History::ApiKeyCustomProviderResume => {initial.codex.shutdown_and_wait().await?;let rollout_path = initial.codex.rollout_path().expect("rollout");if matches!(history, History::Rollback | History::IncompleteRollback) {@@ -239,13 +248,34 @@ async fn model_switch_program_pair(+ "\n",)?;}- if matches!(history, History::ApiKeyResume) {+ if matches!(+ history,+ History::ApiKeyResume+ | History::ApiKeyEnabledResume+ | History::ApiKeyCustomProviderResume+ ) {builder = builder.with_auth(CodexAuth::from_api_key("test-key"));}let resume_config = initial.config.clone();builder = builder.with_config(move |config| {config.model_catalog = resume_config.model_catalog;config.model_provider = resume_config.model_provider;+ if matches!(+ history,+ History::ApiKeyEnabledResume | History::ApiKeyCustomProviderResume+ ) {+ config+ .features+ .enable(Feature::ApiKeyModelDiscovery)+ .expect("enable API-key model discovery");+ config+ .features+ .enable(Feature::ApiKeyCyberAccessPrograms)+ .expect("enable API-key Cyber access programs");+ }+ if matches!(history, History::ApiKeyCustomProviderResume) {+ config.model_provider_id = "custom".to_owned();+ }set_test_compact_prompt(config);});resumed = builder@@ -301,7 +331,25 @@ async fn model_switch_program_pair(submit_pair(&thread, next_model, Some(CyberAccessProgram::DaybreakRed)).await?;thread.shutdown_and_wait().await?;let requests = requests.requests();- let new_program = json!({"cyber": "daybreak_red"});+ if matches!(+ history,+ History::ApiKeyEnabledResume | History::ApiKeyCustomProviderResume+ ) {+ for request in &requests {+ assert_eq!(+ request.header("authorization").as_deref(),+ Some("Bearer test-key")+ );+ }+ }+ let (old_program, new_program) = if matches!(history, History::ApiKeyCustomProviderResume) {+ for request in &requests {+ assert_eq!(request.body_json().get("access_programs"), None);+ }+ (Value::Null, Value::Null)+ } else {+ (expected_program, json!({"cyber": "daybreak_red"}))+ };let actual = requests.iter().map(|request| {@@ -316,9 +364,133 @@ async fn model_switch_program_pair(}following.push(json!([next_model, new_program]));assert_eq!(&actual[1..], following.as_slice());- assert_eq!(actual[0], json!([previous_model, expected_program]));+ assert_eq!(actual[0], json!([previous_model, old_program]));if !local {assert_eq!(requests[0].inputs_of_type("compaction_trigger").len(), 1);}Ok(())}++#[test_case("next-model", Some(CyberAccessProgram::Standard); "standard after model switch")]+#[test_case("gpt-5.5", None; "omitted after same model hash change")]+#[test_case("next-model", Some(CyberAccessProgram::DaybreakBlue); "explicit blue remains denied")]+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn api_key_resume_compaction_retries_current_program(+ current_model: &str,+ current_program: Option<CyberAccessProgram>,+) -> Result<()> {+ skip_if_no_network!(Ok(()));+ let server = start_mock_server().await;+ let previous_model = "gpt-5.5";+ let mut previous =+ model_info_with_context_window(previous_model, /*context_window*/ 273_000);+ previous.comp_hash = Some("previous-hash".to_owned());+ let mut current = previous.clone();+ current.slug = current_model.to_owned();+ current.comp_hash = Some("current-hash".to_owned());+ let initial_models = ModelsResponse {+ models: vec![previous.clone()],+ };+ let mut provider = openai_model_provider(&server);+ provider.stream_max_retries = Some(0);+ let mut builder = test_codex()+ .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())+ .with_model(previous_model)+ .with_config(move |config| {+ config.model_catalog = Some(initial_models.clone());+ config.model_provider = provider;+ });+ let initial = builder.build_with_auto_env(&server).await?;+ mount_sse_once(+ &server,+ sse(vec![+ ev_assistant_message("history", "previous history"),+ ev_completed_with_tokens("history", /*total_tokens*/ 100),+ ]),+ )+ .await;+ submit_pair(+ &initial.codex,+ previous_model,+ Some(CyberAccessProgram::DaybreakBlue),+ )+ .await?;+ initial.codex.shutdown_and_wait().await?;+ server.reset().await;++ // The resumed API key lacks Blue access, including when Blue is explicitly requested again.+ let denied = ResponseTemplate::new(/*s*/ 403).set_body_json(json!({"error": {+ "message": "API key is not entitled to daybreak_blue"+ }}));+ let mut replies = vec![denied.clone()];+ if current_program == Some(CyberAccessProgram::DaybreakBlue) {+ replies.push(denied);+ } else {+ replies.push(sse_response(sse(vec![+ json!({"type": "response.output_item.done", "item": {+ "type": "compaction", "encrypted_content": "AUTHORIZED_SUMMARY"+ }}),+ ev_completed_with_tokens("compact", /*total_tokens*/ 10),+ ])));+ replies.push(sse_response(sse(vec![ev_completed("current")])));+ }+ let requests = mount_response_sequence(&server, replies).await;+ let models = if current_model == previous_model {+ vec![current]+ } else {+ vec![previous, current]+ };+ let provider = initial.config.model_provider.clone();+ builder = builder+ .with_auth(CodexAuth::from_api_key("test-key"))+ .with_config(move |config| {+ config.model_catalog = Some(ModelsResponse { models });+ config.model_provider = provider;+ config+ .features+ .enable(Feature::ApiKeyModelDiscovery)+ .expect("enable API-key model discovery");+ config+ .features+ .enable(Feature::ApiKeyCyberAccessPrograms)+ .expect("enable API-key Cyber access programs");+ });+ let resumed = builder+ .resume(+ &server,+ Arc::clone(&initial.home),+ initial.codex.rollout_path().expect("rollout"),+ )+ .await?;+ let result = submit_pair(&resumed.codex, current_model, current_program).await;+ resumed.codex.shutdown_and_wait().await?;+ let requests = requests.requests();+ for request in &requests {+ assert_eq!(+ request.header("authorization").as_deref(),+ Some("Bearer test-key")+ );+ }+ let requests = requests+ .iter()+ .map(|request| {+ let body = request.body_json();+ json!([body["model"], body["access_programs"]])+ })+ .collect::<Vec<_>>();+ let program = current_program+ .map(|program| json!({"cyber": program}))+ .unwrap_or(Value::Null);+ let mut expected = vec![+ json!([previous_model, {"cyber": "daybreak_blue"}]),+ json!([current_model, program]),+ ];+ if current_program == Some(CyberAccessProgram::DaybreakBlue) {+ assert!(result.is_err(), "explicit Blue unexpectedly succeeded");+ } else {+ assert!(result.is_ok(), "{result:?}; requests: {requests:?}");+ expected.push(json!([current_model, program]));+ }+ assert_eq!(requests, expected);+ Ok(())+}diff --git a/codex-rs/core/tests/suite/cyber_access_program.rs b/codex-rs/core/tests/suite/cyber_access_program.rsindex 1d7ee9adae..dbb709aa2b 100644--- a/codex-rs/core/tests/suite/cyber_access_program.rs+++ b/codex-rs/core/tests/suite/cyber_access_program.rs@@ -20,6 +20,7 @@ use core_test_support::test_codex::test_codex;use core_test_support::wait_for_event;use pretty_assertions::assert_eq;use serde_json::json;+use test_case::test_case;use tokio::sync::oneshot;use wiremock::Mock;use wiremock::matchers::header;@@ -161,9 +162,9 @@ async fn recover_turn_restores_cyber_access_program_without_making_it_sticky() -#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn cyber_access_program_omits_spoofed_custom_providers() -> Result<()> {core_test_support::skip_if_no_network!(Ok(()));- for (auth, provider_id) in [- (CodexAuth::from_api_key("test-key"), "custom"),- (CodexAuth::create_dummy_chatgpt_auth_for_testing(), "custom"),+ for auth in [+ CodexAuth::from_api_key("test-key"),+ CodexAuth::create_dummy_chatgpt_auth_for_testing(),] {let server = responses::start_mock_server().await;let request = responses::mount_sse_once(@@ -173,9 +174,9 @@ async fn cyber_access_program_omits_spoofed_custom_providers() -> Result<()> {.await;let test = test_codex().with_auth(auth)- .with_config(move |config| {+ .with_config(|config| {// Keep the display name "OpenAI": provider identity must not use it.- config.model_provider_id = provider_id.to_owned();+ config.model_provider_id = "custom".to_owned();}).build_with_auto_env(&server).await?;@@ -188,8 +189,12 @@ async fn cyber_access_program_omits_spoofed_custom_providers() -> Result<()> {Ok(())}+#[test_case(CodexAuth::create_dummy_chatgpt_auth_for_testing(); "chatgpt")]+#[test_case(CodexAuth::from_api_key("test-api-key"); "api_key")]#[tokio::test(flavor = "multi_thread", worker_threads = 2)]-async fn cyber_access_program_survives_mid_turn_remote_compaction_v2() -> Result<()> {+async fn cyber_access_program_survives_mid_turn_remote_compaction_v2(+ auth: CodexAuth,+) -> Result<()> {core_test_support::skip_if_no_network!(Ok(()));let server = responses::start_mock_server().await;let requests = responses::mount_sse_sequence(@@ -216,8 +221,18 @@ async fn cyber_access_program_survives_mid_turn_remote_compaction_v2() -> Result).await;let test = test_codex()- .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())- .with_config(|config| config.model_auto_compact_token_limit = Some(200))+ .with_auth(auth)+ .with_config(|config| {+ config.model_auto_compact_token_limit = Some(200);+ config+ .features+ .enable(Feature::ApiKeyModelDiscovery)+ .expect("enable API-key model discovery");+ config+ .features+ .enable(Feature::ApiKeyCyberAccessPrograms)+ .expect("enable API-key Cyber access programs");+ }).build_with_auto_env(&server).await?;@@ -391,8 +406,12 @@ async fn cyber_access_program_is_inherited_by_child_turns() -> Result<()> {Ok(())}+#[test_case(CodexAuth::create_dummy_chatgpt_auth_for_testing(); "chatgpt")]+#[test_case(CodexAuth::from_api_key("test-api-key"); "api_key")]#[tokio::test(flavor = "multi_thread", worker_threads = 2)]-async fn cyber_access_program_changes_on_one_websocket_with_response_reuse() -> Result<()> {+async fn cyber_access_program_changes_on_one_websocket_with_response_reuse(+ auth: CodexAuth,+) -> Result<()> {core_test_support::skip_if_no_network!(Ok(()));let response_ids = ["prewarm", "first", "second", "blue", "red", "off", "omitted",@@ -405,7 +424,17 @@ async fn cyber_access_program_changes_on_one_websocket_with_response_reuse() ->]).await;let test = test_codex()- .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())+ .with_auth(auth)+ .with_config(|config| {+ config+ .features+ .enable(Feature::ApiKeyModelDiscovery)+ .expect("enable API-key model discovery");+ config+ .features+ .enable(Feature::ApiKeyCyberAccessPrograms)+ .expect("enable API-key Cyber access programs");+ }).build_with_websocket_server(&server).await?;for program in [diff --git a/codex-rs/exec/src/cli.rs b/codex-rs/exec/src/cli.rsindex 0ef0be6af9..6a268da298 100644--- a/codex-rs/exec/src/cli.rs+++ b/codex-rs/exec/src/cli.rs@@ -28,6 +28,11 @@ pub struct Cli {#[arg(long = "thread-source", value_name = "SOURCE", global = true)]pub thread_source: Option<ThreadSource>,+ /// Request an experimental Cyber access program for this turn (OpenAI provider only).+ /// Omit to use server defaults. Not supported with review; fork requires a prompt.+ #[arg(long, value_enum, value_name = "PROGRAM", global = true)]+ pub cyber_access_program: Option<CyberAccessProgramCliArg>,+/// Allow running Codex outside a Git repository.#[arg(long = "skip-git-repo-check", global = true, default_value_t = false)]pub skip_git_repo_check: bool,@@ -80,6 +85,24 @@ pub struct Cli {pub prompt: Option<String>,}+#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]+#[value(rename_all = "snake_case")]+pub enum CyberAccessProgramCliArg {+ Standard,+ DaybreakBlue,+ DaybreakRed,+}++impl From<CyberAccessProgramCliArg> for codex_app_server_protocol::CyberAccessProgram {+ fn from(value: CyberAccessProgramCliArg) -> Self {+ match value {+ CyberAccessProgramCliArg::Standard => Self::Standard,+ CyberAccessProgramCliArg::DaybreakBlue => Self::DaybreakBlue,+ CyberAccessProgramCliArg::DaybreakRed => Self::DaybreakRed,+ }+ }+}+impl std::ops::Deref for Cli {type Target = SharedCliOptions;diff --git a/codex-rs/exec/src/cli_tests.rs b/codex-rs/exec/src/cli_tests.rsindex 423935904a..b6770e1d44 100644--- a/codex-rs/exec/src/cli_tests.rs+++ b/codex-rs/exec/src/cli_tests.rs@@ -11,6 +11,8 @@ fn resume_parses_prompt_after_global_flags() {"--json","--model","gpt-5.2-codex",+ "--cyber-access-program",+ "daybreak_blue","--dangerously-bypass-approvals-and-sandbox","--skip-git-repo-check","--ephemeral",@@ -22,6 +24,10 @@ fn resume_parses_prompt_after_global_flags() {assert!(cli.ephemeral);assert!(cli.ignore_user_config);assert!(cli.ignore_rules);+ assert_eq!(+ cli.cyber_access_program,+ Some(CyberAccessProgramCliArg::DaybreakBlue)+ );let Some(Command::Resume(args)) = cli.command else {panic!("expected resume command");};diff --git a/codex-rs/exec/src/lib.rs b/codex-rs/exec/src/lib.rsindex 6eddf37370..22e481a890 100644--- a/codex-rs/exec/src/lib.rs+++ b/codex-rs/exec/src/lib.rs@@ -233,6 +233,7 @@ struct ExecRunArgs {skip_git_repo_check: bool,stderr_with_ansi: bool,thread_source: ThreadSource,+ cyber_access_program: Option<codex_app_server_protocol::CyberAccessProgram>,}struct ManagedExecWorktree {@@ -268,6 +269,7 @@ pub async fn run_main(cli: Cli, arg0_paths: Arg0DispatchPaths) -> anyhow::Resultstrict_config,shared,thread_source,+ cyber_access_program,skip_git_repo_check,ephemeral,ignore_user_config,@@ -279,6 +281,17 @@ pub async fn run_main(cli: Cli, arg0_paths: Arg0DispatchPaths) -> anyhow::Resultoutput_schema: output_schema_path,mut config_overrides,} = cli;+ if cyber_access_program.is_some() {+ match command.as_ref() {+ Some(ExecCommand::Review(_)) => {+ anyhow::bail!("--cyber-access-program is not supported with `codex exec review`");+ }+ Some(ExecCommand::Fork(args)) if args.prompt.is_none() && prompt.is_none() => {+ anyhow::bail!("Forking with --cyber-access-program requires a prompt");+ }+ Some(ExecCommand::Resume(_) | ExecCommand::Fork(_)) | None => {}+ }+ }let mut shared = shared.into_inner();shared.take_auto_review_config_overrides(&mut config_overrides);let SharedCliOptions {@@ -757,6 +770,7 @@ pub async fn run_main(cli: Cli, arg0_paths: Arg0DispatchPaths) -> anyhow::Resultskip_git_repo_check,stderr_with_ansi,thread_source: thread_source.map(Into::into).unwrap_or(ThreadSource::User),+ cyber_access_program: cyber_access_program.map(Into::into),}).instrument(exec_span).await@@ -858,6 +872,7 @@ async fn run_exec_session(args: ExecRunArgs) -> anyhow::Result<()> {skip_git_repo_check,stderr_with_ansi,thread_source,+ cyber_access_program,} = args;if config.daybreak_enabled && !matches!(&command, Some(ExecCommand::Review(_))) {@@ -1191,14 +1206,19 @@ async fn run_exec_session(args: ExecRunArgs) -> anyhow::Result<()> {items,output_schema,} => {- let cyber_access_program = daybreak::program_for_turn(- &client,- &mut request_ids,- &session_configured.model,- &session_configured.model_provider_id,- daybreak_enabled,- )- .await?;+ let cyber_access_program = match cyber_access_program {+ Some(program) => Some(program),+ None => {+ daybreak::program_for_turn(+ &client,+ &mut request_ids,+ &session_configured.model,+ &session_configured.model_provider_id,+ daybreak_enabled,+ )+ .await?+ }+ };let response: TurnStartResponse = send_request_with_response(&client,ClientRequest::TurnStart {diff --git a/codex-rs/exec/tests/suite/cyber_access_program_tests.rs b/codex-rs/exec/tests/suite/cyber_access_program_tests.rsnew file mode 100644index 0000000000..f942da8d50--- /dev/null+++ b/codex-rs/exec/tests/suite/cyber_access_program_tests.rs@@ -0,0 +1,102 @@+//! Verify exec forwards Cyber selection per turn and rejects unsupported commands.++use core_test_support::responses;+use core_test_support::skip_if_no_network;+use core_test_support::test_codex_exec::test_codex_exec;+use pretty_assertions::assert_eq;+use serde_json::Value;+use serde_json::json;++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn cyber_access_program_is_selected_per_turn() -> anyhow::Result<()> {+ skip_if_no_network!(Ok(()));++ let test = test_codex_exec();+ std::fs::write(+ test.home_path().join("config.toml"),+ "[features]\napi_key_cyber_access_programs = true\napi_key_model_discovery = true\n",+ )?;+ let server = responses::start_mock_server().await;+ let response_mock = responses::mount_sse_sequence(+ &server,+ (0..4)+ .map(|index| {+ responses::sse(vec![responses::ev_completed(&format!(+ "resp-cyber-{index}"+ ))])+ })+ .collect(),+ )+ .await;++ let seed = test+ .cmd_with_server(&server)+ .args([+ "--skip-git-repo-check",+ "--json",+ "--cyber-access-program",+ "daybreak_blue",+ "Respond only OK.",+ ])+ .assert()+ .success();+ let events = std::str::from_utf8(&seed.get_output().stdout)?+ .lines()+ .map(serde_json::from_str::<Value>)+ .collect::<Result<Vec<_>, _>>()?;+ let thread_id = events+ .iter()+ .find(|event| event["type"] == "thread.started")+ .and_then(|event| event["thread_id"].as_str())+ .expect("new turn should emit a thread id");++ for (command, prompt, program) in [+ ("resume", "Respond only OK.", Some("daybreak_red")),+ ("fork", "-", Some("standard")),+ ("fork", "Respond only OK.", None),+ ] {+ let mut cmd = test.cmd_with_server(&server);+ cmd.args(["--skip-git-repo-check", command, thread_id]);+ if let Some(program) = program {+ cmd.args(["--cyber-access-program", program]);+ }+ if prompt == "-" {+ cmd.write_stdin("Respond only OK.");+ }+ cmd.arg(prompt).assert().success();+ }++ assert_eq!(+ response_mock+ .requests()+ .iter()+ .map(|request| request.body_json().get("access_programs").cloned())+ .collect::<Vec<_>>(),+ vec![+ Some(json!({"cyber": "daybreak_blue"})),+ Some(json!({"cyber": "daybreak_red"})),+ Some(json!({"cyber": "standard"})),+ None,+ ]+ );+ Ok(())+}++#[test]+fn cyber_access_program_requires_a_supported_turn() {+ let test = test_codex_exec();+ for (args, message) in [+ (+ vec!["review", "--uncommitted"],+ "is not supported with `codex exec review`",+ ),+ (vec!["fork", "synthetic-session"], "requires a prompt"),+ ] {+ test.cmd()+ .args(["--cyber-access-program", "daybreak_blue"])+ .args(args)+ .assert()+ .failure()+ .stderr(predicates::str::contains(message));+ }+}diff --git a/codex-rs/exec/tests/suite/daybreak.rs b/codex-rs/exec/tests/suite/daybreak.rsindex 0b03c8dabc..2f021e4b9f 100644--- a/codex-rs/exec/tests/suite/daybreak.rs+++ b/codex-rs/exec/tests/suite/daybreak.rs@@ -212,6 +212,46 @@ async fn exec_resumes_and_forks_the_saved_daybreak_choice() -> anyhow::Result<()Ok(())}+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn exec_explicit_cyber_program_overrides_daybreak_for_one_turn() -> anyhow::Result<()> {+ let (test, server) = configured_daybreak_exec().await?;+ let response =+ responses::mount_sse_once(&server, responses::sse_completed("explicit-program")).await;+ let output = test+ .cmd_with_server(&server)+ .env_remove("CODEX_ACCESS_TOKEN")+ .env_remove("CODEX_API_KEY")+ .env_remove("OPENAI_API_KEY")+ .args([+ "--skip-git-repo-check",+ "--json",+ "--cyber-access-program",+ "daybreak_red",+ "hello",+ ])+ .output()?;+ let thread_id = started_thread(output)?;+ assert_eq!(+ response.single_request().body_json()["access_programs"],+ json!({"cyber": "daybreak_red"})+ );++ let response =+ responses::mount_sse_once(&server, responses::sse_completed("saved-daybreak")).await;+ test.cmd_with_server(&server)+ .env_remove("CODEX_ACCESS_TOKEN")+ .env_remove("CODEX_API_KEY")+ .env_remove("OPENAI_API_KEY")+ .args(["--skip-git-repo-check", "resume", &thread_id, "continue"])+ .assert()+ .success();+ assert_eq!(+ response.single_request().body_json()["access_programs"],+ json!({"cyber": "daybreak_blue"})+ );+ Ok(())+}+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn exec_resume_override_does_not_change_a_standard_thread() -> anyhow::Result<()> {let (test, server) = configured_daybreak_exec().await?;diff --git a/codex-rs/exec/tests/suite/mod.rs b/codex-rs/exec/tests/suite/mod.rsindex de152560c9..baf2957b82 100644--- a/codex-rs/exec/tests/suite/mod.rs+++ b/codex-rs/exec/tests/suite/mod.rs@@ -6,6 +6,8 @@ mod approval_policy;mod auth_env;#[path = "completion_backfill_tests.rs"]mod completion_backfill;+#[path = "cyber_access_program_tests.rs"]+mod cyber_access_program;mod daybreak;mod ephemeral;mod hooks;diff --git a/sdk/typescript/src/exec.ts b/sdk/typescript/src/exec.tsindex 853caff471..e1735d2c76 100644--- a/sdk/typescript/src/exec.ts+++ b/sdk/typescript/src/exec.ts@@ -6,6 +6,7 @@ import { createRequire } from "node:module";import type { CodexConfigObject, CodexConfigValue } from "./codexOptions";import { SandboxMode, ModelReasoningEffort, ApprovalMode, WebSearchMode } from "./threadOptions";+import type { CyberAccessProgram } from "./turnOptions";export type CodexExecArgs = {input: string;@@ -28,6 +29,8 @@ export type CodexExecArgs = {skipGitRepoCheck?: boolean;// --output-schemaoutputSchemaFile?: string;+ // --cyber-access-program+ cyberAccessProgram?: CyberAccessProgram;// --config model_reasoning_effortmodelReasoningEffort?: ModelReasoningEffort;// AbortSignal to cancel the execution@@ -140,6 +143,10 @@ export class CodexExec {commandArgs.push("--output-schema", args.outputSchemaFile);}+ if (args.cyberAccessProgram !== undefined) {+ commandArgs.push("--cyber-access-program", args.cyberAccessProgram);+ }+if (args.modelReasoningEffort) {commandArgs.push("--config", `model_reasoning_effort="${args.modelReasoningEffort}"`);}diff --git a/sdk/typescript/src/index.ts b/sdk/typescript/src/index.tsindex a74f391a74..cfda99024c 100644--- a/sdk/typescript/src/index.ts+++ b/sdk/typescript/src/index.ts@@ -37,4 +37,4 @@ export type {ModelReasoningEffort,WebSearchMode,} from "./threadOptions";-export type { TurnOptions } from "./turnOptions";+export type { CyberAccessProgram, TurnOptions } from "./turnOptions";diff --git a/sdk/typescript/src/thread.ts b/sdk/typescript/src/thread.tsindex b34463e570..ead1767a94 100644--- a/sdk/typescript/src/thread.ts+++ b/sdk/typescript/src/thread.ts@@ -86,6 +86,7 @@ export class Thread {workingDirectory: options?.workingDirectory,skipGitRepoCheck: options?.skipGitRepoCheck,outputSchemaFile: schemaPath,+ cyberAccessProgram: turnOptions.cyberAccessProgram,modelReasoningEffort: options?.modelReasoningEffort,signal: turnOptions.signal,networkAccessEnabled: options?.networkAccessEnabled,diff --git a/sdk/typescript/src/turnOptions.ts b/sdk/typescript/src/turnOptions.tsindex 1eda806694..f63d0ebe0a 100644--- a/sdk/typescript/src/turnOptions.ts+++ b/sdk/typescript/src/turnOptions.ts@@ -1,4 +1,11 @@+export type CyberAccessProgram = "standard" | "daybreak_blue" | "daybreak_red";+export type TurnOptions = {+ /**+ * Experimental Cyber selection for this turn with the built-in OpenAI provider.+ * Omit to use server defaults.+ */+ cyberAccessProgram?: CyberAccessProgram;/** JSON schema describing the expected agent output. */outputSchema?: unknown;/** AbortSignal to cancel the turn. */diff --git a/sdk/typescript/tests/run.test.ts b/sdk/typescript/tests/run.test.tsindex 9729c597b7..34a2742d1d 100644--- a/sdk/typescript/tests/run.test.ts+++ b/sdk/typescript/tests/run.test.ts@@ -229,6 +229,48 @@ describe("Codex", () => {}});+ it("passes cyber access program selections only to the turns that specify them", async () => {+ const { url, close } = await startResponsesTestProxy({+ responseBodies: [+ sse(responseCompleted("response_1")),+ sse(responseCompleted("response_2")),+ sse(responseCompleted("response_3")),+ sse(responseCompleted("response_4")),+ ],+ });+ const { args: spawnArgs, restore } = codexExecSpy();+ const { client, cleanup } = createMockClient(url);++ try {+ const thread = client.startThread();+ await thread.run("select blue", { cyberAccessProgram: "daybreak_blue" });+ const threadId = thread.id;+ expect(threadId).toEqual(expect.any(String));++ const streamed = await thread.runStreamed("select red", {+ cyberAccessProgram: "daybreak_red",+ });+ for await (const _ of streamed.events) {+ // Consume the streamed turn before resuming the thread.+ }+ await thread.run("select standard", { cyberAccessProgram: "standard" });+ await thread.run("use automatic selection");++ expect(spawnArgs).toHaveLength(4);+ expectPair(spawnArgs[0], ["--cyber-access-program", "daybreak_blue"]);+ expectPair(spawnArgs[1], ["--cyber-access-program", "daybreak_red"]);+ expectPair(spawnArgs[2], ["--cyber-access-program", "standard"]);+ expect(spawnArgs[3]).not.toContain("--cyber-access-program");+ for (const args of spawnArgs.slice(1)) {+ expectPair(args, ["resume", threadId!]);+ }+ } finally {+ cleanup();+ restore();+ await close();+ }+ }, 15_000);+it.each(["high", "persistent"] as const)("passes %s modelReasoningEffort to exec",async (effort) => {