Lightweight coding agent that runs in your terminal
Rust
Support explicit cyber access programs with OpenAI API keys (#49406)
Brian Lee7c35e1551f72
diff --git a/codex-rs/app-server-protocol/schema/json/ClientRequest.json b/codex-rs/app-server-protocol/schema/json/ClientRequest.jsonindex dbac6c0f66..458e63efca 100644--- a/codex-rs/app-server-protocol/schema/json/ClientRequest.json+++ b/codex-rs/app-server-protocol/schema/json/ClientRequest.json@@ -762,7 +762,7 @@"type": "string"},"CyberAccessProgram": {- "description": "Requested cyber treatment for a ChatGPT-authenticated Codex turn. Authorization and model-tier restrictions remain server-owned.",+ "description": "Requested cyber treatment for an OpenAI model turn. Authorization and model-tier restrictions remain server-owned.","enum": ["standard","daybreakBlue",diff --git a/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.schemas.json b/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.schemas.jsonindex a4dc6548af..fb7684cabf 100644--- a/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.schemas.json+++ b/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.schemas.json@@ -10712,7 +10712,7 @@"type": "object"},"CyberAccessProgram": {- "description": "Requested cyber treatment for a ChatGPT-authenticated Codex turn. Authorization and model-tier restrictions remain server-owned.",+ "description": "Requested cyber treatment for an OpenAI model turn. Authorization and model-tier restrictions remain server-owned.","enum": ["standard","daybreakBlue",diff --git a/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.v2.schemas.json b/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.v2.schemas.jsonindex 75ecacf9c2..acdc575506 100644--- a/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.v2.schemas.json+++ b/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.v2.schemas.json@@ -6568,7 +6568,7 @@"type": "object"},"CyberAccessProgram": {- "description": "Requested cyber treatment for a ChatGPT-authenticated Codex turn. Authorization and model-tier restrictions remain server-owned.",+ "description": "Requested cyber treatment for an OpenAI model turn. Authorization and model-tier restrictions remain server-owned.","enum": ["standard","daybreakBlue",diff --git a/codex-rs/app-server-protocol/schema/json/v2/ModelListResponse.json b/codex-rs/app-server-protocol/schema/json/v2/ModelListResponse.jsonindex 8169ec1e8d..ee3ca9ae14 100644--- a/codex-rs/app-server-protocol/schema/json/v2/ModelListResponse.json+++ b/codex-rs/app-server-protocol/schema/json/v2/ModelListResponse.json@@ -2,7 +2,7 @@"$schema": "http://json-schema.org/draft-07/schema#","definitions": {"CyberAccessProgram": {- "description": "Requested cyber treatment for a ChatGPT-authenticated Codex turn. Authorization and model-tier restrictions remain server-owned.",+ "description": "Requested cyber treatment for an OpenAI model turn. Authorization and model-tier restrictions remain server-owned.","enum": ["standard","daybreakBlue",diff --git a/codex-rs/app-server-protocol/schema/json/v2/TurnStartParams.json b/codex-rs/app-server-protocol/schema/json/v2/TurnStartParams.jsonindex c0cb6dfd4a..751bb8bc4e 100644--- a/codex-rs/app-server-protocol/schema/json/v2/TurnStartParams.json+++ b/codex-rs/app-server-protocol/schema/json/v2/TurnStartParams.json@@ -121,7 +121,7 @@"type": "object"},"CyberAccessProgram": {- "description": "Requested cyber treatment for a ChatGPT-authenticated Codex turn. Authorization and model-tier restrictions remain server-owned.",+ "description": "Requested cyber treatment for an OpenAI model turn. Authorization and model-tier restrictions remain server-owned.","enum": ["standard","daybreakBlue",diff --git a/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zst b/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zstindex 5838b537c5..6aa5e5bfed 100644Binary files a/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zst and b/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zst differdiff --git a/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-stable.json.zst b/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-stable.json.zstindex e8bfb39944..72fe29bf62 100644Binary files a/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-stable.json.zst and b/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-stable.json.zst differdiff --git a/codex-rs/app-server-protocol/schema/typescript/v2/CyberAccessProgram.ts b/codex-rs/app-server-protocol/schema/typescript/v2/CyberAccessProgram.tsindex ccd4118a83..0b87ec9cc6 100644--- a/codex-rs/app-server-protocol/schema/typescript/v2/CyberAccessProgram.ts+++ b/codex-rs/app-server-protocol/schema/typescript/v2/CyberAccessProgram.ts@@ -3,7 +3,7 @@// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually./**- * Requested cyber treatment for a ChatGPT-authenticated Codex turn.+ * Requested cyber treatment for an OpenAI model turn.* Authorization and model-tier restrictions remain server-owned.*/export type CyberAccessProgram = "standard" | "daybreakBlue" | "daybreakRed";diff --git a/codex-rs/app-server-protocol/src/protocol/v2/turn.rs b/codex-rs/app-server-protocol/src/protocol/v2/turn.rsindex f938d179e6..f7a7ec09ea 100644--- a/codex-rs/app-server-protocol/src/protocol/v2/turn.rs+++ b/codex-rs/app-server-protocol/src/protocol/v2/turn.rs@@ -118,7 +118,7 @@ pub struct AdditionalContextEntry {pub kind: AdditionalContextKind,}-/// Requested cyber treatment for a ChatGPT-authenticated Codex turn.+/// Requested cyber treatment for an OpenAI model turn./// Authorization and model-tier restrictions remain server-owned.#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq, JsonSchema, TS)]#[serde(rename_all = "camelCase")]@@ -271,7 +271,7 @@ pub struct TurnStartParams {#[ts(optional = nullable)]pub multi_agent_mode: Option<MultiAgentMode>,- /// EXPERIMENTAL - Request a workspace-authorized cyber program for this+ /// EXPERIMENTAL - Request an authorized cyber program for this/// turn. Omission preserves automatic behavior. This does not grant access.#[experimental("turn/start.cyberAccessProgram")]#[ts(optional = nullable)]diff --git a/codex-rs/app-server/src/request_processors/config_processor.rs b/codex-rs/app-server/src/request_processors/config_processor.rsindex 56a8b4b316..72ddca52f6 100644--- a/codex-rs/app-server/src/request_processors/config_processor.rs+++ b/codex-rs/app-server/src/request_processors/config_processor.rs@@ -64,6 +64,7 @@ const BACKGROUND_PAGINATED_ROLLOUT_MIGRATION_FEATURE: &str ="background_paginated_rollout_migration";const SUPPORTED_EXPERIMENTAL_FEATURE_ENABLEMENT: &[&str] = &[+ "api_key_cyber_access_programs","api_key_model_discovery","auth_elicitation",BACKGROUND_PAGINATED_ROLLOUT_MIGRATION_FEATURE,diff --git a/codex-rs/app-server/tests/suite/v2/cyber_access_program.rs b/codex-rs/app-server/tests/suite/v2/cyber_access_program.rsindex fea72f3f56..6cfedf7706 100644--- a/codex-rs/app-server/tests/suite/v2/cyber_access_program.rs+++ b/codex-rs/app-server/tests/suite/v2/cyber_access_program.rs@@ -3,7 +3,10 @@ use app_test_support::ChatGptAuthFixture;use app_test_support::TestAppServer;use app_test_support::write_chatgpt_auth;use codex_app_server_protocol::ClientRequest;+use codex_app_server_protocol::CodexErrorInfo;use codex_app_server_protocol::CyberAccessProgram;+use codex_app_server_protocol::ExperimentalFeatureEnablementSetParams;+use codex_app_server_protocol::ExperimentalFeatureEnablementSetResponse;use codex_app_server_protocol::JSONRPCErrorError;use codex_app_server_protocol::RequestId;use codex_app_server_protocol::ThreadForkParams;@@ -16,13 +19,18 @@ use codex_app_server_protocol::ThreadResumeParams;use codex_app_server_protocol::ThreadResumeResponse;use codex_app_server_protocol::ThreadStartParams;use codex_app_server_protocol::ThreadStartedNotification;+use codex_app_server_protocol::TurnError;use codex_app_server_protocol::TurnStartParams;use codex_app_server_protocol::TurnStatus;use codex_app_server_protocol::UserInput;use codex_login::AuthCredentialsStoreMode;+use codex_login::AuthKeyringBackendKind;+use codex_login::login_with_api_key;use core_test_support::responses;use pretty_assertions::assert_eq;use serde_json::json;+use std::collections::BTreeMap;+use std::collections::HashMap;use std::path::Path;use tempfile::TempDir;use wiremock::Mock;@@ -192,6 +200,167 @@ async fn turn_start_forwards_explicit_cyber_access_program() -> Result<()> {Ok(())}+#[tokio::test]+async fn api_key_cyber_access_program_requires_both_features() -> Result<()> {+ core_test_support::skip_if_no_network!(Ok(()));+ let server = responses::start_mock_server().await;+ let expected_programs = [+ None,+ None,+ None,+ Some(json!({"cyber": "daybreak_blue"})),+ Some(json!({"cyber": "daybreak_red"})),+ Some(json!({"cyber": "standard"})),+ ];+ let requests = responses::mount_sse_sequence(+ &server,+ expected_programs+ .iter()+ .enumerate()+ .map(|(index, _)| responses::sse_completed(&format!("resp-{index}")))+ .collect(),+ )+ .await;+ let home = TempDir::new()?;+ let mut app = start_api_key_app(home.path(), &server).await?;+ set_api_key_cyber_access_programs(&mut app, /*enabled*/ true).await?;+ for disabled_feature in [+ Some("api_key_cyber_access_programs"),+ Some("api_key_model_discovery"),+ None,+ ] {+ let thread = app+ .start_thread(ThreadStartParams {+ config: disabled_feature+ .map(|feature| HashMap::from([(format!("features.{feature}"), json!(false))])),+ ..Default::default()+ })+ .await?+ .thread;+ for program in [+ None,+ Some(CyberAccessProgram::DaybreakBlue),+ Some(CyberAccessProgram::DaybreakRed),+ Some(CyberAccessProgram::Standard),+ ] {+ let completed = app+ .start_turn_and_wait_for_completion(TurnStartParams {+ thread_id: thread.id.clone(),+ cyber_access_program: program,+ input: vec![UserInput::Text {+ text: "hello".to_owned(),+ text_elements: Vec::new(),+ }],+ ..Default::default()+ })+ .await?;+ if program.is_some() && disabled_feature.is_some() {+ assert_eq!(completed.turn.status, TurnStatus::Failed);+ assert_eq!(+ completed.turn.error,+ Some(TurnError {+ message: "Cyber access programs are disabled for this API-key session."+ .to_owned(),+ codex_error_info: Some(CodexErrorInfo::Other),+ additional_details: None,+ misalignment: None,+ })+ );+ } else {+ assert_eq!(completed.turn.status, TurnStatus::Completed);+ }+ }+ }+ assert_eq!(+ requests+ .requests()+ .iter()+ .map(|request| (+ request.header("authorization"),+ request.body_json()["model"].clone(),+ request.body_json().get("access_programs").cloned(),+ ))+ .collect::<Vec<_>>(),+ expected_programs+ .into_iter()+ .map(|program| (+ Some("Bearer test-key".to_owned()),+ json!("gpt-6-sol"),+ program+ ))+ .collect::<Vec<_>>()+ );+ app.shutdown_gracefully().await?;+ Ok(())+}++#[tokio::test]+async fn api_key_cyber_access_program_server_rejection_does_not_fall_back() -> Result<()> {+ core_test_support::skip_if_no_network!(Ok(()));+ let server = responses::start_mock_server().await;+ Mock::given(method("POST"))+ .and(path("/v1/responses"))+ .respond_with(ResponseTemplate::new(/*s*/ 403).set_body_json(json!({+ "error": {+ "type": "invalid_request_error",+ "code": "access_program_not_enabled",+ "message": "Daybreak Blue is not enabled for this project."+ }+ })))+ .expect(/*r*/ 1..)+ .mount(&server)+ .await;+ let home = TempDir::new()?;+ let mut app = start_api_key_app(home.path(), &server).await?;+ set_api_key_cyber_access_programs(&mut app, /*enabled*/ true).await?;+ let thread = app.start_thread(ThreadStartParams::default()).await?.thread;+ let completed = app+ .start_turn_and_wait_for_completion(TurnStartParams {+ thread_id: thread.id,+ cyber_access_program: Some(CyberAccessProgram::DaybreakBlue),+ input: vec![UserInput::Text {+ text: "hello".to_owned(),+ text_elements: Vec::new(),+ }],+ ..Default::default()+ })+ .await?;+ assert_eq!(completed.turn.status, TurnStatus::Failed);+ let error = completed.turn.error.expect("server rejection");+ assert_eq!(+ error.codex_error_info,+ Some(CodexErrorInfo::HttpConnectionFailed {+ http_status_code: Some(403),+ })+ );+ assert!(+ error+ .message+ .contains("Daybreak Blue is not enabled for this project.")+ );+ let requests = responses::received_responses_requests(&server).await;+ assert!(!requests.is_empty());+ // Existing transport retries may repeat the request; none may drop the program.+ assert_eq!(+ requests+ .iter()+ .map(|request| (+ request.header("authorization"),+ request.body_json()["access_programs"].clone()+ ))+ .collect::<Vec<_>>(),+ vec![+ (+ Some("Bearer test-key".to_owned()),+ json!({"cyber": "daybreak_blue"})+ );+ requests.len()+ ]+ );+ app.shutdown_gracefully().await?;+ Ok(())+}+#[tokio::test]async fn daybreak_thread_metadata_persists_independently_across_restart_and_fork() -> Result<()> {core_test_support::skip_if_no_network!(Ok(()));@@ -461,3 +630,55 @@ async fn start_chatgpt_app(home: &Path, server: &MockServer) -> Result<TestAppSe.build_initialized().await}++async fn start_api_key_app(home: &Path, server: &MockServer) -> Result<TestAppServer> {+ Mock::given(method("GET"))+ .and(path("/v1/responses"))+ .respond_with(ResponseTemplate::new(/*s*/ 426))+ .mount(server)+ .await;+ // The existing inference override disables remote catalog discovery. Forwarding+ // must therefore work without granting programs through a test catalog.+ std::fs::write(+ home.join("config.toml"),+ format!(+ "model = \"gpt-6-sol\"\nopenai_base_url = \"{}/v1\"\n[features]\napi_key_model_discovery = true\n",+ server.uri()+ ),+ )?;+ login_with_api_key(+ home,+ "test-key",+ AuthCredentialsStoreMode::File,+ AuthKeyringBackendKind::default(),+ )?;+ TestAppServer::builder()+ .with_codex_home(home)+ .without_managed_config()+ .with_env_overrides(&[+ ("OPENAI_API_KEY", None),+ ("CODEX_API_KEY", None),+ ("OPENAI_BASE_URL", None),+ ])+ .build_initialized()+ .await+}++async fn set_api_key_cyber_access_programs(app: &mut TestAppServer, enabled: bool) -> Result<()> {+ let enablement = BTreeMap::from([("api_key_cyber_access_programs".to_owned(), enabled)]);+ let response: ExperimentalFeatureEnablementSetResponse = app+ .request(+ |request_id| ClientRequest::ExperimentalFeatureEnablementSet {+ request_id,+ params: ExperimentalFeatureEnablementSetParams {+ enablement: enablement.clone(),+ },+ },+ )+ .await?;+ assert_eq!(+ response,+ ExperimentalFeatureEnablementSetResponse { enablement }+ );+ Ok(())+}diff --git a/codex-rs/core/config.schema.json b/codex-rs/core/config.schema.jsonindex d5521009b9..6aaa39c3f5 100644--- a/codex-rs/core/config.schema.json+++ b/codex-rs/core/config.schema.json@@ -713,6 +713,9 @@"analytics_plan_history": {"type": "boolean"},+ "api_key_cyber_access_programs": {+ "type": "boolean"+ },"api_key_model_discovery": {"type": "boolean"},@@ -6740,6 +6743,9 @@"analytics_plan_history": {"type": "boolean"},+ "api_key_cyber_access_programs": {+ "type": "boolean"+ },"api_key_model_discovery": {"type": "boolean"},diff --git a/codex-rs/core/src/client.rs b/codex-rs/core/src/client.rsindex f5ac495337..e852b632d8 100644--- a/codex-rs/core/src/client.rs+++ b/codex-rs/core/src/client.rs@@ -272,6 +272,8 @@ pub struct ModelClient {restored_history: bool,request_contributors: Vec<Arc<dyn codex_extension_api::ModelRequestContributor>>,executed_tool_calls: Option<ExecutedToolCalls>,+ // Resolved once when the session is created, like other session feature flags.+ api_key_cyber_access_programs: cyber_access_program::ApiKeyCyberAccessPrograms,}/// A turn-scoped streaming session created from a [`ModelClient`].@@ -541,6 +543,8 @@ impl ModelClient {restored_history: false,request_contributors,executed_tool_calls: None,+ api_key_cyber_access_programs:+ cyber_access_program::ApiKeyCyberAccessPrograms::UnsupportedProvider,}}@@ -565,10 +569,12 @@ impl ModelClient {prompt_cache_key_override: Option<String>,event_sender: Sender<ProtocolEvent>,codex_responses_headers: Option<Arc<CodexResponsesHeaders>>,+ api_key_cyber_access_programs: cyber_access_program::ApiKeyCyberAccessPrograms,) -> Self {self.prompt_cache_key_override = prompt_cache_key_override;self.event_sender = Some(event_sender);self.codex_responses_headers = codex_responses_headers;+ self.api_key_cyber_access_programs = api_key_cyber_access_programs;self}@@ -1730,7 +1736,8 @@ impl ModelClientSession {request.access_programs = cyber_access_program::for_auth(client_setup.auth.as_ref(),prompt.cyber_access_program,- );+ self.client.api_key_cyber_access_programs,+ )?;self.client.prepare_response_items_for_request(&mut request.input);if crate::guardian::is_basic_session_source(&self.client.state.session_source) {@@ -1889,7 +1896,8 @@ impl ModelClientSession {request.access_programs = cyber_access_program::for_auth(client_setup.auth.as_ref(),prompt.cyber_access_program,- );+ self.client.api_key_cyber_access_programs,+ )?;let mut websocket_metadata = responses_metadata.clone();websocket_metadata.routing_hint = self.client.build_routing_hint_header(client_setup.auth.as_ref(),diff --git a/codex-rs/core/src/cyber_access_program.rs b/codex-rs/core/src/cyber_access_program.rsindex 4a508715fd..7f75798562 100644--- a/codex-rs/core/src/cyber_access_program.rs+++ b/codex-rs/core/src/cyber_access_program.rs@@ -1,12 +1,55 @@+//! Forward explicit programs while leaving entitlement and model policy to the server.+use codex_api::AccessPrograms;+use codex_features::Feature;use codex_login::CodexAuth;+use codex_protocol::error::CodexErr;+use codex_protocol::error::Result;use codex_protocol::turn_input::CyberAccessProgram;+#[derive(Clone, Copy, Debug)]+pub(crate) enum ApiKeyCyberAccessPrograms {+ UnsupportedProvider,+ Disabled,+ Enabled,+}++impl ApiKeyCyberAccessPrograms {+ pub(crate) fn from_config(config: &crate::config::Config) -> Self {+ if config.model_provider_id != codex_model_provider_info::OPENAI_PROVIDER_ID {+ Self::UnsupportedProvider+ } else if config.features.enabled(Feature::ApiKeyCyberAccessPrograms)+ && config.features.enabled(Feature::ApiKeyModelDiscovery)+ {+ Self::Enabled+ } else {+ Self::Disabled+ }+ }+}+pub(crate) fn for_auth(auth: Option<&CodexAuth>,program: Option<CyberAccessProgram>,-) -> Option<AccessPrograms> {- program- .filter(|_| auth.is_some_and(CodexAuth::is_chatgpt_auth))- .map(AccessPrograms::from)+ policy: ApiKeyCyberAccessPrograms,+) -> Result<Option<AccessPrograms>> {+ let Some(program) = program else {+ return Ok(None);+ };+ let Some(auth) = auth else {+ return Ok(None);+ };+ if auth.is_chatgpt_auth() {+ return Ok(Some(program.into()));+ }+ if !auth.is_api_key_auth() {+ return Ok(None);+ }+ match policy {+ ApiKeyCyberAccessPrograms::UnsupportedProvider => Ok(None),+ ApiKeyCyberAccessPrograms::Disabled => Err(CodexErr::InvalidRequest(+ "Cyber access programs are disabled for this API-key session.".to_owned(),+ )),+ ApiKeyCyberAccessPrograms::Enabled => Ok(Some(program.into())),+ }}diff --git a/codex-rs/core/src/session/session.rs b/codex-rs/core/src/session/session.rsindex 824cf589cd..e92aaeef8a 100644--- a/codex-rs/core/src/session/session.rs+++ b/codex-rs/core/src/session/session.rs@@ -1763,6 +1763,7 @@ impl Session {.or(fork_cache_key),tx_event.clone(),codex_responses_headers,+ crate::cyber_access_program::ApiKeyCyberAccessPrograms::from_config(&config),),executed_tool_calls: executed_tool_calls.clone(),code_mode_service: crate::tools::code_mode::CodeModeService::new(diff --git a/codex-rs/core/src/tools/executed_tool_calls/request_metadata_tests.rs b/codex-rs/core/src/tools/executed_tool_calls/request_metadata_tests.rsindex efa05e24e6..9b75f4d4ac 100644--- a/codex-rs/core/src/tools/executed_tool_calls/request_metadata_tests.rs+++ b/codex-rs/core/src/tools/executed_tool_calls/request_metadata_tests.rs@@ -534,6 +534,8 @@ async fn recorder_refreshes_without_changing_execution_features_or_claiming_misscrate::ConfigRefreshOutcome::Published);let mut replay = output(&call.call_id);+ // Replay the same history item across the configuration refresh.+ replay.set_id(direct_output.id().cloned());calls.attach_direct_call_to_output(&mut replay, prepared);assert_eq!(replay, direct_output);}diff --git a/codex-rs/core/tests/suite/compact_program_tests.rs b/codex-rs/core/tests/suite/compact_program_tests.rsindex d65c36660d..3a357df410 100644--- a/codex-rs/core/tests/suite/compact_program_tests.rs+++ b/codex-rs/core/tests/suite/compact_program_tests.rs@@ -254,6 +254,30 @@ async fn model_switch_program_pair(Arc::clone(&resumed.codex)}};+ if matches!(history, History::ApiKeyResume) {+ // Resuming a ChatGPT turn does not enable the API-key rollout features.+ let error = submit_pair(&thread, next_model, Some(CyberAccessProgram::DaybreakRed))+ .await+ .expect_err("API-key selections require the rollout features");+ assert!(+ error+ .to_string()+ .contains("Cyber access programs are disabled for this API-key session.")+ );+ thread.shutdown_and_wait().await?;+ assert_eq!(+ server+ .received_requests()+ .await+ .expect("recorded fixture requests")+ .iter()+ .filter(|request| request.method == "POST" && request.url.path() == "/v1/responses")+ .count(),+ 1,+ "only the original ChatGPT turn should reach inference"+ );+ return Ok(());+ }let summary = if local {ev_assistant_message("summary", "summary of surviving history")} else {@@ -277,17 +301,7 @@ 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 authorized = !matches!(history, History::ApiKeyResume);- let old_program = if authorized {- expected_program- } else {- Value::Null- };- let new_program = if authorized {- json!({"cyber": "daybreak_red"})- } else {- Value::Null- };+ let new_program = json!({"cyber": "daybreak_red"});let actual = requests.iter().map(|request| {@@ -302,7 +316,7 @@ 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, old_program]));+ assert_eq!(actual[0], json!([previous_model, expected_program]));if !local {assert_eq!(requests[0].inputs_of_type("compaction_trigger").len(), 1);}diff --git a/codex-rs/core/tests/suite/cyber_access_program.rs b/codex-rs/core/tests/suite/cyber_access_program.rsindex e5021c0f03..1d7ee9adae 100644--- a/codex-rs/core/tests/suite/cyber_access_program.rs+++ b/codex-rs/core/tests/suite/cyber_access_program.rs@@ -159,10 +159,10 @@ 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_api_key_and_spoofed_custom_provider() -> Result<()> {+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"), "openai"),+ (CodexAuth::from_api_key("test-key"), "custom"),(CodexAuth::create_dummy_chatgpt_auth_for_testing(), "custom"),] {let server = responses::start_mock_server().await;diff --git a/codex-rs/features/src/lib.rs b/codex-rs/features/src/lib.rsindex 2b6d26acb3..7f61ef3aee 100644--- a/codex-rs/features/src/lib.rs+++ b/codex-rs/features/src/lib.rs@@ -96,6 +96,8 @@ pub enum Feature {AnalyticsPlanHistory,/// Discover model catalogs for OpenAI API-key authentication.ApiKeyModelDiscovery,+ /// Forward explicit programs with builtin OpenAI API keys.+ ApiKeyCyberAccessPrograms,/// Deprecated no-op; use `tui.fullscreen_transcript` instead.TranscriptV2,// Stable.@@ -1300,6 +1302,12 @@ pub const FEATURES: &[FeatureSpec] = &[stage: Stage::UnderDevelopment,default_enabled: false,},+ FeatureSpec {+ id: Feature::ApiKeyCyberAccessPrograms,+ key: "api_key_cyber_access_programs",+ stage: Stage::Stable,+ default_enabled: false,+ },FeatureSpec {id: Feature::EnableRequestCompression,key: "enable_request_compression",diff --git a/codex-rs/protocol/src/turn_input.rs b/codex-rs/protocol/src/turn_input.rsindex e7c17ead2f..cb27cd4f96 100644--- a/codex-rs/protocol/src/turn_input.rs+++ b/codex-rs/protocol/src/turn_input.rs@@ -142,7 +142,7 @@ pub enum TurnInputMode {Steer { expected_turn_id: String },}-/// Requested cyber treatment for a ChatGPT-authenticated Codex turn.+/// Requested cyber treatment for an OpenAI model turn./// Authorization and model-tier restrictions remain server-owned.#[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq, Eq, JsonSchema, TS)]#[serde(rename_all = "snake_case")]