diff --git a/backend/crates/gateway-admin/src/model/settings.rs b/backend/crates/gateway-admin/src/model/settings.rs index a056ac24c..f08daf4c7 100644 --- a/backend/crates/gateway-admin/src/model/settings.rs +++ b/backend/crates/gateway-admin/src/model/settings.rs @@ -5,6 +5,7 @@ use std::{collections::BTreeMap, fmt}; use chrono::{DateTime, Utc}; use gateway_core::routing::{ProviderKind, PublicModelId, UpstreamModelId}; +use gateway_core::settings::default_oauth_guardian_review_model; use super::Revision; @@ -83,6 +84,10 @@ pub struct RuntimeSettingsValues { #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)] #[serde(deny_unknown_fields)] pub struct RuntimeSettings { + #[serde(default = "default_oauth_guardian_review_model")] + pub openai_oauth_guardian_review_model: bool, + #[serde(default)] + pub openai_request_country: gateway_core::account::OpenAiRequestCountry, #[serde(flatten)] pub values: RuntimeSettingsValues, pub request_profiles: ProviderRequestProfiles, @@ -96,6 +101,11 @@ pub struct RuntimeSettings { #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)] #[serde(deny_unknown_fields)] pub struct ReplaceRuntimeSettings { + /// 旧客户端缺少此字段时保留已保存的审核模型策略 + #[serde(default, skip_serializing_if = "Option::is_none")] + pub openai_oauth_guardian_review_model: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub openai_request_country: Option, #[serde(flatten)] pub values: RuntimeSettingsValues, /// 读取设置时的版本;与写入在同一事务内比较,防止覆盖并发更新 @@ -176,6 +186,8 @@ impl From for ReplaceRuntimeSettings { fn from(settings: RuntimeSettings) -> Self { Self { expected_revision: settings.config_revision, + openai_oauth_guardian_review_model: Some(settings.openai_oauth_guardian_review_model), + openai_request_country: Some(settings.openai_request_country), request_profile_updates: settings .request_profiles .into_iter() diff --git a/backend/crates/gateway-admin/src/use_case/settings.rs b/backend/crates/gateway-admin/src/use_case/settings.rs index ce54937d8..f7bc62806 100644 --- a/backend/crates/gateway-admin/src/use_case/settings.rs +++ b/backend/crates/gateway-admin/src/use_case/settings.rs @@ -109,6 +109,11 @@ impl DefaultSettingsService { } fn validate_settings(command: &ReplaceRuntimeSettings) -> Result<(), AdminError> { + if let Some(policy) = &command.openai_request_country { + policy + .validate() + .map_err(|_| AdminError::invalid("请求国家必须是两位大写 ASCII 字母"))?; + } crate::model::settings::validate_model_mappings( command .model_mappings diff --git a/backend/crates/gateway-admin/tests/use_case/accounts/mod.rs b/backend/crates/gateway-admin/tests/use_case/accounts/mod.rs index c597d68a1..6689e7703 100644 --- a/backend/crates/gateway-admin/tests/use_case/accounts/mod.rs +++ b/backend/crates/gateway-admin/tests/use_case/accounts/mod.rs @@ -1168,6 +1168,8 @@ impl SettingsStore for StaticSettingsStore { } async fn load_runtime_settings(&self) -> AdminStoreResult { Ok(RuntimeSettings { + openai_oauth_guardian_review_model: false, + openai_request_country: Default::default(), request_profiles: Default::default(), config_revision: revision(1), model_mappings: Default::default(), diff --git a/backend/crates/gateway-admin/tests/use_case/freeze_recovery.rs b/backend/crates/gateway-admin/tests/use_case/freeze_recovery.rs index 65c38e3b7..c65f37fa7 100644 --- a/backend/crates/gateway-admin/tests/use_case/freeze_recovery.rs +++ b/backend/crates/gateway-admin/tests/use_case/freeze_recovery.rs @@ -27,6 +27,8 @@ use super::accounts::{FakeAccountStore, FakeProviderAdmin, account_record, event fn runtime_settings(enabled: bool, probe_enabled: bool) -> RuntimeSettings { RuntimeSettings { + openai_oauth_guardian_review_model: false, + openai_request_country: Default::default(), request_profiles: Default::default(), config_revision: revision(1), model_mappings: Default::default(), diff --git a/backend/crates/gateway-admin/tests/use_case/observability/mod.rs b/backend/crates/gateway-admin/tests/use_case/observability/mod.rs index 3d30e234a..71951b30c 100644 --- a/backend/crates/gateway-admin/tests/use_case/observability/mod.rs +++ b/backend/crates/gateway-admin/tests/use_case/observability/mod.rs @@ -1425,6 +1425,8 @@ impl SettingsStore for FixtureSettingsStore { } async fn load_runtime_settings(&self) -> AdminStoreResult { Ok(RuntimeSettings { + openai_oauth_guardian_review_model: false, + openai_request_country: Default::default(), request_profiles: Default::default(), config_revision: Revision::new(1).expect("revision"), model_mappings: Default::default(), diff --git a/backend/crates/gateway-admin/tests/use_case/service_contract.rs b/backend/crates/gateway-admin/tests/use_case/service_contract.rs index 5de965bdb..c202a1cb6 100644 --- a/backend/crates/gateway-admin/tests/use_case/service_contract.rs +++ b/backend/crates/gateway-admin/tests/use_case/service_contract.rs @@ -254,7 +254,7 @@ fn sdk_settings_contract_matches_host_declarations() { ), ( "../gateway-core/src/account/location.rs", - &["RequestLocation"][..], + &["RequestLocation", "OpenAiRequestCountry"][..], ), ( "../gateway-core/src/account/scheduling.rs", @@ -344,9 +344,11 @@ fn sdk_settings_contract_matches_host_declarations() { assert_eq!(operations.len(), method_count, "公开服务方法必须完整声明"); let assignments = replacement_fields.iter().map(|field| match field.to_string().as_str() { "expected_revision" => quote!(expected_revision: settings.config_revision), + "openai_oauth_guardian_review_model" | "openai_request_country" => quote!(#field: Some(settings.#field)), "request_profile_updates" => quote!(request_profile_updates: settings.request_profiles.into_iter().map(|(provider, value)| (provider, Some(value))).collect()), _ => quote!(#field: settings.#field), }); + let default_review_model = gateway_core::settings::default_oauth_guardian_review_model(); let generated = quote! { //! 宿主设置服务的操作标识与请求、响应数据合同 //! @@ -362,7 +364,11 @@ fn sdk_settings_contract_matches_host_declarations() { pub type RotationStrategy = String; pub type AccountAffinity = String; pub type PricingOverrides = BTreeMap>; + fn default_oauth_guardian_review_model() -> bool { #default_review_model } #(#types)* + impl Default for OpenAiRequestCountry { + fn default() -> Self { Self::FollowLocation {} } + } #(#operations)* impl From for ReplaceRuntimeSettings { fn from(settings: RuntimeSettings) -> Self { diff --git a/backend/crates/gateway-admin/tests/use_case/settings.rs b/backend/crates/gateway-admin/tests/use_case/settings.rs index 6ef0d93e5..83a48843c 100644 --- a/backend/crates/gateway-admin/tests/use_case/settings.rs +++ b/backend/crates/gateway-admin/tests/use_case/settings.rs @@ -320,6 +320,8 @@ async fn settings_should_reject_zero_refresh_margin_before_store_call() { request_id: "request-settings".to_owned(), }, ReplaceRuntimeSettings { + openai_oauth_guardian_review_model: None, + openai_request_country: None, expected_revision: gateway_admin::model::Revision::new(1).unwrap(), request_profile_updates: Default::default(), model_mappings: Default::default(), diff --git a/backend/crates/gateway-api/src/admin/settings.rs b/backend/crates/gateway-api/src/admin/settings.rs index 92c42084d..3c518f7bf 100644 --- a/backend/crates/gateway-api/src/admin/settings.rs +++ b/backend/crates/gateway-api/src/admin/settings.rs @@ -74,6 +74,8 @@ pub struct RuntimeSettingsFields { #[derive(Debug, Clone, PartialEq, Eq, Serialize)] #[serde(rename_all = "camelCase")] pub struct RuntimeSettingsView { + pub openai_oauth_guardian_review_model: bool, + pub openai_request_country: gateway_core::account::OpenAiRequestCountry, #[serde(flatten)] pub values: RuntimeSettingsFields, pub config_revision: u64, @@ -94,16 +96,20 @@ pub struct RuntimeSettingsView { #[derive(Debug, Clone, PartialEq, Eq, Deserialize)] #[serde(rename_all = "camelCase", deny_unknown_fields)] pub struct UpdateRuntimeSettingsRequest { + #[serde(default, deserialize_with = "deserialize_present_update")] + pub openai_oauth_guardian_review_model: Option, + #[serde(default, deserialize_with = "deserialize_present_update")] + pub openai_request_country: Option, #[serde(flatten)] pub values: RuntimeSettingsFields, pub config_revision: u64, #[serde(default)] pub provider_request_profiles: ProviderRequestProfileUpdates, /// 兼容既有 wire;与泛化字段冲突时拒绝整个请求 - #[serde(default, deserialize_with = "deserialize_profile_update")] + #[serde(default, deserialize_with = "deserialize_present_update")] pub openai_client_profile: Option>, /// 兼容既有 wire;与泛化字段冲突时拒绝整个请求 - #[serde(default, deserialize_with = "deserialize_profile_update")] + #[serde(default, deserialize_with = "deserialize_present_update")] pub xai_client_profile: Option>, pub model_mappings: ModelMappings, pub rotation_strategy: String, @@ -112,6 +118,7 @@ pub struct UpdateRuntimeSettingsRequest { impl UpdateRuntimeSettingsRequest { /// 校验公共运行参数 pub fn validate(&self) -> Result<(), WireValidationError> { + self.validate_request_country()?; validate_model_mappings(&self.model_mappings)?; if RotationStrategy::parse(&self.rotation_strategy).is_none() { return Err(WireValidationError::new("rotationStrategy")); @@ -120,6 +127,7 @@ impl UpdateRuntimeSettingsRequest { } fn into_command(self) -> Result { + self.validate_request_country()?; validate_model_mappings(&self.model_mappings)?; let request_profile_updates = normalize_request_profile_updates( self.provider_request_profiles, @@ -127,6 +135,8 @@ impl UpdateRuntimeSettingsRequest { self.xai_client_profile, )?; Ok(ReplaceRuntimeSettings { + openai_oauth_guardian_review_model: self.openai_oauth_guardian_review_model, + openai_request_country: self.openai_request_country, expected_revision: gateway_admin::model::Revision::new(self.config_revision) .map_err(|_| WireValidationError::new("configRevision"))?, request_profile_updates, @@ -136,6 +146,15 @@ impl UpdateRuntimeSettingsRequest { values: self.values.into_values()?, }) } + + fn validate_request_country(&self) -> Result<(), WireValidationError> { + if let Some(policy) = &self.openai_request_country { + policy + .validate() + .map_err(|_| WireValidationError::new("openaiRequestCountry"))?; + } + Ok(()) + } } impl From<(RuntimeSettings, crate::time::TimePresenter)> for RuntimeSettingsView { @@ -147,6 +166,8 @@ impl From<(RuntimeSettings, crate::time::TimePresenter)> for RuntimeSettingsView .collect::(); Self { config_revision: settings.config_revision.get(), + openai_oauth_guardian_review_model: settings.openai_oauth_guardian_review_model, + openai_request_country: settings.openai_request_country, openai_client_profile: provider_request_profiles.get("openai").cloned(), xai_client_profile: provider_request_profiles.get("xai").cloned(), provider_request_profiles, @@ -595,6 +616,7 @@ fn map_wire_error(error: WireValidationError) -> AdminError { "settingsUsageRetentionOverflow" => "用量记录保留天数不合法".to_owned(), "settingsOpsRetentionOverflow" => "运维事件保留天数不合法".to_owned(), "settingsAuditRetentionOverflow" => "审计记录保留天数不合法".to_owned(), + "openaiRequestCountry" => "自定义请求国家必须是两位大写 ASCII 字母".to_owned(), "requestLocation" => "请求位置的国家代码、地区或城市不合法".to_owned(), "providerRequestProfiles" => "服务商客户端身份配置无效或字段冲突".to_owned(), "minCodexDesktopVersion" => "Codex Desktop 最低版本格式不合法".to_owned(), @@ -645,11 +667,11 @@ fn normalize_request_profile_updates( Ok(normalized) } -// 字段省略时保留已有配置;显式 null 不能清空唯一的通用默认 -fn deserialize_profile_update<'de, D: serde::Deserializer<'de>>( +// 字段省略时保留已有配置;显式 null 不能清空设置 +fn deserialize_present_update<'de, D: serde::Deserializer<'de>, T: Deserialize<'de>>( deserializer: D, -) -> Result>, D::Error> { - serde_json::Map::::deserialize(deserializer).map(Some) +) -> Result, D::Error> { + T::deserialize(deserializer).map(Some) } async fn detect_location( diff --git a/backend/crates/gateway-api/src/openai/responses/request.rs b/backend/crates/gateway-api/src/openai/responses/request.rs index 35a8f8adc..c60fbb650 100644 --- a/backend/crates/gateway-api/src/openai/responses/request.rs +++ b/backend/crates/gateway-api/src/openai/responses/request.rs @@ -33,6 +33,8 @@ pub(super) enum RequestDecodeSource { #[derive(Clone, Default)] pub struct OpenAiRequestHeaders { + guardian: Option, + ambiguous_guardian_headers: bool, turn_state: Option, turn_metadata: Option, version: Option, @@ -57,6 +59,17 @@ impl OpenAiRequestHeaders { #[must_use] pub fn from_headers(headers: &HeaderMap) -> Self { Self { + guardian: header_string(headers, "x-codex-guardian"), + ambiguous_guardian_headers: [ + "x-codex-guardian", + OPENAI_SUBAGENT_KEY, + "x-codex-turn-metadata", + ] + .into_iter() + .any(|name| { + let mut values = headers.get_all(name).iter(); + values.next().is_some_and(|v| v.to_str().is_err()) || values.next().is_some() + }), turn_state: header_string(headers, "x-codex-turn-state"), turn_metadata: header_string(headers, "x-codex-turn-metadata"), version: header_string(headers, "version"), @@ -87,7 +100,46 @@ impl OpenAiRequestHeaders { self } - fn apply_subagent(&self, body: &mut Map) { + fn apply_subagent( + &self, + body: &mut Map, + context: &mut Map, + source: RequestDecodeSource, + ) { + if matches!(source, RequestDecodeSource::WebSocketFrame) + && let Some(frame_agent) = body + .get("client_metadata") + .and_then(|m| m.get(OPENAI_SUBAGENT_KEY)) + .and_then(Value::as_str) + && (frame_agent == "guardian" + || self.subagent.as_deref() == Some("guardian") + || self.guardian.is_some()) + { + // 帧内声明优先;旧 opening 的不透明副本也不能在 Provider 再度覆盖 + let stale_subagent = self + .subagent + .as_deref() + .is_some_and(|opening| opening != frame_agent); + let stale_guardian = self.guardian.as_deref().is_some_and(|opening| { + frame_agent != "guardian" + || gateway_protocol::openai::codex_guardian_role(body, context) + .is_some_and(|role| role.header() != Some(opening)) + }); + if stale_subagent { + context.insert("subagent".into(), Value::from(frame_agent)); + } + if (stale_subagent || stale_guardian) + && let Some(Value::Array(headers)) = + context.get_mut(PASSTHROUGH_HEADERS_CONTEXT_KEY) + { + headers.retain(|pair| match pair.get(0).and_then(Value::as_str) { + Some(OPENAI_SUBAGENT_KEY) => !stale_subagent, + Some("x-codex-guardian") => !stale_guardian, + _ => true, + }); + } + return; + } if let Some(subagent) = self.subagent.as_deref() { inject_subagent_metadata(body, subagent); } @@ -329,8 +381,14 @@ pub(super) fn decode_request_object( .map(|response_id| ContinuationIntent::PreviousResponseId(response_id.to_owned())) .unwrap_or(ContinuationIntent::None); - request_headers.apply_subagent(&mut object); - let protocol_context = request_headers.protocol_context(use_websocket, source); + let mut protocol_context = request_headers.protocol_context(use_websocket, source); + gateway_protocol::openai::capture_codex_guardian_identity( + &object, + &mut protocol_context, + request_headers.guardian.as_deref(), + request_headers.ambiguous_guardian_headers, + ); + request_headers.apply_subagent(&mut object, &mut protocol_context, source); let semantics = gateway_protocol::openai::codex_responses_request_semantics(&object, &protocol_context); diff --git a/backend/crates/gateway-api/src/openai/responses/websocket/mod.rs b/backend/crates/gateway-api/src/openai/responses/websocket/mod.rs index 76ff7f9b5..a20cece7e 100644 --- a/backend/crates/gateway-api/src/openai/responses/websocket/mod.rs +++ b/backend/crates/gateway-api/src/openai/responses/websocket/mod.rs @@ -332,6 +332,13 @@ async fn serve_responses_websocket(socket: Socket, session: ResponsesWebSocketSe // 握手的轮次头只属于首次执行,复用连接时由各 response.create 携带本轮数据 raw_headers.remove("x-codex-turn-state"); raw_headers.remove("x-codex-turn-metadata"); + raw_headers.remove("x-codex-guardian"); + if raw_headers + .get("x-openai-subagent") + .is_some_and(|value| value == "guardian") + { + raw_headers.remove("x-openai-subagent"); + } let service_for_terminal = service.clone(); let replay_for_terminal = replay.clone(); let connection_id_for_terminal = connection.id().to_owned(); diff --git a/backend/crates/gateway-api/tests/admin/mod.rs b/backend/crates/gateway-api/tests/admin/mod.rs index 368b61b1b..b9b0a1963 100644 --- a/backend/crates/gateway-api/tests/admin/mod.rs +++ b/backend/crates/gateway-api/tests/admin/mod.rs @@ -636,6 +636,12 @@ impl SettingsStore for MemorySettingsStore { } } let updated = RuntimeSettings { + openai_oauth_guardian_review_model: command + .openai_oauth_guardian_review_model + .unwrap_or(settings.openai_oauth_guardian_review_model), + openai_request_country: command + .openai_request_country + .unwrap_or_else(|| settings.openai_request_country.clone()), request_profiles, config_revision: next_revision(settings.config_revision), model_mappings: command.model_mappings, @@ -1990,6 +1996,9 @@ fn test_runtime_settings() -> RuntimeSettings { ), ]); RuntimeSettings { + openai_oauth_guardian_review_model: + gateway_core::settings::default_oauth_guardian_review_model(), + openai_request_country: Default::default(), request_profiles: Default::default(), config_revision: Revision::new(7).expect("revision"), model_mappings: mappings, diff --git a/backend/crates/gateway-api/tests/admin/settings.rs b/backend/crates/gateway-api/tests/admin/settings.rs index 7c232e7d8..bf5c28113 100644 --- a/backend/crates/gateway-api/tests/admin/settings.rs +++ b/backend/crates/gateway-api/tests/admin/settings.rs @@ -523,6 +523,13 @@ fn settings_service_contract_flattens_values_and_rejects_unknown_fields() { serde_json::from_value::(record.clone()).unwrap(), current ); + let mut legacy = record.as_object().unwrap().clone(); + legacy.remove("openai_oauth_guardian_review_model"); + legacy.remove("openai_request_country"); + assert_eq!( + serde_json::from_value::(Value::Object(legacy)).unwrap(), + current + ); record["unexpected_setting"] = json!(true); assert!(serde_json::from_value::(record).is_err()); @@ -536,6 +543,12 @@ fn settings_service_contract_flattens_values_and_rejects_unknown_fields() { serde_json::from_value::(wire.clone()).unwrap(), command ); + let mut legacy = wire.as_object().unwrap().clone(); + legacy.remove("openai_oauth_guardian_review_model"); + legacy.remove("openai_request_country"); + let legacy = serde_json::from_value::(Value::Object(legacy)).unwrap(); + assert_eq!(legacy.openai_oauth_guardian_review_model, None); + assert_eq!(legacy.openai_request_country, None); wire["unexpected_setting"] = json!(true); assert!(serde_json::from_value::(wire).is_err()); } @@ -1416,6 +1429,86 @@ async fn settings_update_rejects_a_stale_version_without_replacing_the_saved_val ); } +#[tokio::test] +async fn openai_request_settings_preserve_omitted_fields_and_reject_stale_writes() { + let fixture = AdminTestFixture::new().await; + fixture.auth.insert_session("valid-session"); + let read = || app(fixture.state()).oneshot(request(Method::GET, "/api/admin/settings", None)); + let save = |body| { + app(fixture.state()).oneshot(request( + Method::POST, + "/api/admin/settings/update", + Some(body), + )) + }; + let initial = response_json(read().await.unwrap()).await["data"].clone(); + assert_eq!(initial["openaiOauthGuardianReviewModel"], true); + assert_eq!( + initial["openaiRequestCountry"], + json!({"mode":"follow_location"}) + ); + let mut body = update_body(); + body["configRevision"] = initial["configRevision"].clone(); + body["openaiOauthGuardianReviewModel"] = json!(false); + body["openaiRequestCountry"] = json!({"mode":"custom","country":"CA"}); + let response = save(body.clone()).await.unwrap(); + assert_eq!(response.status(), StatusCode::OK); + let saved = response_json(response).await["data"].clone(); + assert_eq!(saved["openaiOauthGuardianReviewModel"], false); + assert_eq!(saved["openaiRequestCountry"], body["openaiRequestCountry"]); + + let mut legacy = update_body(); + legacy["configRevision"] = saved["configRevision"].clone(); + assert_eq!(save(legacy).await.unwrap().status(), StatusCode::OK); + body["openaiOauthGuardianReviewModel"] = json!(true); + body["openaiRequestCountry"] = json!({"mode":"passthrough"}); + assert_eq!( + save(body.clone()).await.unwrap().status(), + StatusCode::CONFLICT + ); + let current = response_json(read().await.unwrap()).await["data"].clone(); + assert_eq!(current["openaiOauthGuardianReviewModel"], false); + assert_eq!( + current["openaiRequestCountry"], + saved["openaiRequestCountry"] + ); + body["configRevision"] = current["configRevision"].clone(); + let response = save(body).await.unwrap(); + assert_eq!(response.status(), StatusCode::OK); + let changed = response_json(response).await["data"].clone(); + assert_eq!(changed["openaiOauthGuardianReviewModel"], true); + assert_eq!( + changed["openaiRequestCountry"], + json!({"mode":"passthrough"}) + ); +} + +#[test] +fn openai_request_settings_validate_modes_and_country_codes() { + for invalid in [ + json!(null), + json!({"mode":"custom"}), + json!({"mode":"custom","country":"ca"}), + json!({"mode":"custom","country":"USA"}), + json!({"mode":"custom","country":"国"}), + json!({"mode":"follow_location","country":"CA"}), + json!({"mode":"passthrough","country":"CA"}), + json!({"mode":"default","country":"CA"}), + json!({"mode":"unknown"}), + ] { + let mut body = update_body(); + body["openaiRequestCountry"] = invalid.clone(); + if let Ok(request) = serde_json::from_value::(body) { + assert!(request.validate().is_err(), "{invalid}"); + } + } + for invalid in [json!(null), json!("true"), json!(1)] { + let mut body = update_body(); + body["openaiOauthGuardianReviewModel"] = invalid; + assert!(serde_json::from_value::(body).is_err()); + } +} + #[tokio::test] async fn guardian_reservation_round_trips_and_rejects_invalid_values() { let fixture = AdminTestFixture::new().await; diff --git a/backend/crates/gateway-api/tests/openai/responses/mod.rs b/backend/crates/gateway-api/tests/openai/responses/mod.rs index a09cb7aba..5ce071375 100644 --- a/backend/crates/gateway-api/tests/openai/responses/mod.rs +++ b/backend/crates/gateway-api/tests/openai/responses/mod.rs @@ -34,6 +34,215 @@ fn generate_request(body: Value) -> DecodedGenerationRequest { decode_request(body.to_string().as_bytes()).expect("test request should decode") } +#[test] +fn guardian_roles_should_use_complete_current_request_identity_before_header_projection() { + use gateway_protocol::openai::{CodexGuardianRole::*, codex_guardian_role}; + + let review = r#"{"thread_source":"guardian_review"}"#; + let classification = + r#"{"thread_source":"guardian_classifier","turn_trigger":"guardian_classifier"}"#; + let housekeeping = r#"{"turn_trigger":"guardian_housekeeper"}"#; + for (websocket, body_agent, body_turn, header_agent, header_turn, explicit, expected) in [ + ( + false, + Some("guardian"), + Some(review), + None, + None, + None, + Some(Reviewer), + ), + ( + false, + None, + None, + Some("guardian"), + Some(review), + None, + Some(Reviewer), + ), + ( + false, + None, + Some(review), + Some("guardian"), + None, + None, + None, + ), + ( + false, + Some("other"), + Some(review), + Some("guardian"), + Some(review), + None, + None, + ), + ( + false, + Some("guardian"), + Some(classification), + Some("guardian"), + Some(review), + None, + None, + ), + ( + false, + Some("guardian"), + Some("invalid"), + Some("guardian"), + Some(review), + None, + None, + ), + ( + false, + Some("guardian"), + Some(review), + None, + None, + Some("classifier"), + None, + ), + (false, None, None, None, None, Some("reviewer"), None), + ( + false, + Some("guardian"), + Some(classification), + None, + None, + None, + Some(Classifier), + ), + ( + false, + Some("guardian"), + Some(housekeeping), + None, + None, + None, + Some(Housekeeper), + ), + ( + true, + None, + None, + Some("guardian"), + Some(review), + Some("reviewer"), + None, + ), + ( + true, + None, + Some(review), + Some("guardian"), + Some(review), + None, + None, + ), + ( + true, + Some("guardian"), + Some(classification), + Some("stale_agent"), + Some(review), + Some("reviewer"), + Some(Classifier), + ), + ( + true, + Some("guardian"), + Some(review), + None, + None, + None, + Some(Reviewer), + ), + ] { + let mut body = + json!({"model":"gpt-5.6-luna","input":[],"generate":false,"client_metadata":{}}); + if let Some(agent) = body_agent { + body["client_metadata"]["x-openai-subagent"] = json!(agent); + } + if let Some(turn) = body_turn { + body["client_metadata"]["x-codex-turn-metadata"] = json!(turn); + } + let mut headers = HeaderMap::new(); + for (name, value) in [ + ("x-openai-subagent", header_agent), + ("x-codex-turn-metadata", header_turn), + ("x-codex-guardian", explicit), + ] { + if let Some(value) = value { + headers.insert(name, HeaderValue::from_str(value).unwrap()); + } + } + let decoded = if websocket { + body["type"] = json!("response.create"); + decode_response_create_with_context( + &body.to_string(), + &OpenAiRequestHeaders::from_headers(&headers), + ) + .unwrap() + } else { + decode_request_with_headers(body.to_string().as_bytes(), &headers, 64 * 1024).unwrap() + }; + let payload = generate_operation(&decoded).protocol_payload(); + if !websocket && matches!(expected, Some(Classifier | Housekeeper)) { + assert!(!payload.context().contains_key("use_websocket")); + assert!( + !payload + .context() + .contains_key(gateway_protocol::openai::WEBSOCKET_FRAME_CONTEXT_KEY) + ); + } + if websocket && header_agent == Some("stale_agent") { + assert_eq!( + payload.body()["client_metadata"]["x-openai-subagent"], + "guardian" + ); + let opaque = payload.context()["opaque_request_headers"] + .as_array() + .unwrap(); + assert!(!opaque.iter().any(|pair| matches!( + pair[0].as_str(), + Some("x-codex-guardian" | "x-openai-subagent") + ))); + } + assert_eq!( + codex_guardian_role(payload.body(), payload.context()), + expected, + "body={body}, headers={headers:?}" + ); + } + let mut repeated = HeaderMap::new(); + repeated.append("x-openai-subagent", HeaderValue::from_static("guardian")); + repeated.append("x-openai-subagent", HeaderValue::from_static("other")); + repeated.insert("x-codex-turn-metadata", HeaderValue::from_static(review)); + let decoded = decode_request_with_headers( + br#"{"model":"gpt-5.6-luna","input":[]}"#, + &repeated, + 64 * 1024, + ) + .unwrap(); + let payload = generate_operation(&decoded).protocol_payload(); + assert_eq!(codex_guardian_role(payload.body(), payload.context()), None); + for malformed in [ + r#"{"thread_source":"guardian_classifier","thread_source":"guardian_review"}"#, + r#"{"thread_source":null}"#, + r#"["guardian_review"]"#, + ] { + let mut body = json!({"model":"gpt-5.6-luna","input":[],"client_metadata":{"x-openai-subagent":"guardian"}}); + body["client_metadata"]["x-codex-turn-metadata"] = json!(malformed); + let decoded = generate_request(body); + let payload = generate_operation(&decoded).protocol_payload(); + assert_eq!(codex_guardian_role(payload.body(), payload.context()), None); + } +} + #[test] fn decoder_should_attach_only_identified_codex_inference_turns() { let body = json!({"model":"smart-code", "input":"hello", "client_metadata": { diff --git a/backend/crates/gateway-api/tests/openai/responses/websocket/forward.rs b/backend/crates/gateway-api/tests/openai/responses/websocket/forward.rs index 65f266562..e21b1e0d1 100644 --- a/backend/crates/gateway-api/tests/openai/responses/websocket/forward.rs +++ b/backend/crates/gateway-api/tests/openai/responses/websocket/forward.rs @@ -536,6 +536,14 @@ async fn errors_on_a_reused_connection_keep_their_own_upstream_ids() { "x-codex-turn-metadata", axum::http::HeaderValue::from_static(r#"{"request_kind":"turn"}"#), ); + opening.insert( + "x-openai-subagent", + axum::http::HeaderValue::from_static("guardian"), + ); + opening.insert( + "x-codex-guardian", + axum::http::HeaderValue::from_static("reviewer"), + ); let (mut socket, _server) = connect_with_headers(Arc::clone(&trace), Vec::new(), opening).await; for request_id in ["req_first", "req_second"] { send_request(&mut socket).await; @@ -548,9 +556,11 @@ async fn errors_on_a_reused_connection_keep_their_own_upstream_ids() { [ [ Some("opening".to_owned()), - Some(r#"{"request_kind":"turn"}"#.to_owned()) + Some(r#"{"request_kind":"turn"}"#.to_owned()), + Some("guardian".to_owned()), + Some("incomplete".to_owned()), ], - [None, None] + [None, None, None, None] ] ); assert_no_duplicate_failure(&mut socket).await; diff --git a/backend/crates/gateway-api/tests/openai/responses/websocket/mod.rs b/backend/crates/gateway-api/tests/openai/responses/websocket/mod.rs index 8580f704c..5cb2061af 100644 --- a/backend/crates/gateway-api/tests/openai/responses/websocket/mod.rs +++ b/backend/crates/gateway-api/tests/openai/responses/websocket/mod.rs @@ -318,7 +318,7 @@ struct AtomicFailureTrace { committed: AtomicBool, finalized: AtomicBool, downstream_websocket_connection_ids: Mutex>, - request_turn_headers: Mutex; 2]>>, + request_turn_headers: Mutex; 4]>>, initial_errors: Mutex>, first_batch: Mutex>, session_drops: Arc, @@ -450,8 +450,13 @@ impl ExecutionService for AtomicFailureExecution { { let context = generate.protocol_payload().context(); self.trace.request_turn_headers.lock().unwrap().push( - ["turn_state", "turn_metadata"] - .map(|key| context.get(key).and_then(Value::as_str).map(str::to_owned)), + [ + "turn_state", + "turn_metadata", + "subagent", + "codex_guardian_identity", + ] + .map(|key| context.get(key).and_then(Value::as_str).map(str::to_owned)), ); self.trace .downstream_websocket_connection_ids diff --git a/backend/crates/gateway-core/src/account/location.rs b/backend/crates/gateway-core/src/account/location.rs index 92ff31e07..67481b04e 100644 --- a/backend/crates/gateway-core/src/account/location.rs +++ b/backend/crates/gateway-core/src/account/location.rs @@ -11,6 +11,31 @@ pub struct RequestLocation { pub timezone: chrono_tz::Tz, } +/// 独立选择 OpenAI 请求的国家字段,仅自定义模式需要国家代码 +#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)] +#[serde(tag = "mode", rename_all = "snake_case", deny_unknown_fields)] +pub enum OpenAiRequestCountry { + Default {}, + Passthrough {}, + FollowLocation {}, + Custom { country: String }, +} + +impl Default for OpenAiRequestCountry { + fn default() -> Self { + Self::FollowLocation {} + } +} + +impl OpenAiRequestCountry { + pub fn validate(&self) -> Result<(), InvalidRequestLocation> { + if let Self::Custom { country } = self { + validate_country(country)?; + } + Ok(()) + } +} + #[derive(Debug, Clone, Copy, PartialEq, Eq, thiserror::Error)] pub enum InvalidRequestLocation { #[error("country must contain two uppercase ASCII letters")] @@ -34,9 +59,7 @@ impl Default for RequestLocation { impl RequestLocation { pub fn validate(&self) -> Result<(), InvalidRequestLocation> { - if self.country.len() != 2 || !self.country.bytes().all(|byte| byte.is_ascii_uppercase()) { - return Err(InvalidRequestLocation::Country); - } + validate_country(&self.country)?; for (value, error) in [ (&self.region, InvalidRequestLocation::Region), (&self.city, InvalidRequestLocation::City), @@ -59,3 +82,11 @@ impl RequestLocation { Ok(self) } } + +fn validate_country(country: &str) -> Result<(), InvalidRequestLocation> { + if country.len() == 2 && country.bytes().all(|byte| byte.is_ascii_uppercase()) { + Ok(()) + } else { + Err(InvalidRequestLocation::Country) + } +} diff --git a/backend/crates/gateway-core/src/account/mod.rs b/backend/crates/gateway-core/src/account/mod.rs index d160327b3..2c1165ce2 100644 --- a/backend/crates/gateway-core/src/account/mod.rs +++ b/backend/crates/gateway-core/src/account/mod.rs @@ -6,7 +6,7 @@ pub use error_protection::*; mod fast_mode; pub use fast_mode::FastMode; mod location; -pub use location::{InvalidRequestLocation, RequestLocation}; +pub use location::{InvalidRequestLocation, OpenAiRequestCountry, RequestLocation}; mod model; mod model_access; pub use model_access::{ diff --git a/backend/crates/gateway-core/src/engine/coordinator.rs b/backend/crates/gateway-core/src/engine/coordinator.rs index 2a6d413a2..7b154cb97 100644 --- a/backend/crates/gateway-core/src/engine/coordinator.rs +++ b/backend/crates/gateway-core/src/engine/coordinator.rs @@ -1171,6 +1171,7 @@ where .with_fast_mode(self.plan.fast_mode()) .with_pricing(self.plan.pricing()) .with_request_location(self.plan.request_location().cloned()) + .with_openai_request_country(self.plan.openai_request_country().clone()) .with_privacy(self.plan.privacy()) .with_request_body_limit(self.plan.request_body_limit()) .with_concurrency_wait_budget(self.concurrency_wait_budget.clone()) diff --git a/backend/crates/gateway-core/src/engine/execution/service.rs b/backend/crates/gateway-core/src/engine/execution/service.rs index 189fd2d55..6011f04a8 100644 --- a/backend/crates/gateway-core/src/engine/execution/service.rs +++ b/backend/crates/gateway-core/src/engine/execution/service.rs @@ -21,7 +21,7 @@ use crate::{ concurrency::{CapacityWait, ConcurrencyWaitBudget, ConcurrencyWaitQueue}, engine::{ AttemptCoordinator, EngineError, ExecutionStore, GatewayEngine, ModelRequestId, - NewModelRequest, ProbeFailure, ProviderAccountId, UpstreamSendState, + ModelRouteScope, NewModelRequest, ProbeFailure, ProviderAccountId, UpstreamSendState, admission::{ ClientAdmissionDecision, ClientAdmissionPort, ClientAdmissionRejection, ClientAdmissionRequest, @@ -62,7 +62,7 @@ use crate::{ policy::{ClientApiKeyId, ClientPolicy}, provider_ports::{ProviderSessionAffinityPort, ProviderStoreErrorKind}, routing::{ - FrozenAccountScope, ProviderCatalogUnavailable, ProviderModelContent, + DirectAccountModel, FrozenAccountScope, ProviderCatalogUnavailable, ProviderModelContent, PublicModelDescriptor, PublicModelId, RoutingContext, RuntimeSnapshot, UpstreamModelId, request_settings::RequestSettings, }, @@ -508,6 +508,48 @@ impl DefaultExecutionService { } routing_context.required_provider = Some(provider); } + let continuation = match request.metadata.previous_response_id.as_ref() { + Some(previous) => { + let resolve = self + .continuation + .resolve(request.client.policy.key_id(), previous) + .fuse(); + let timeout = Delay::new(COORDINATION_TIMEOUT).fuse(); + pin_mut!(resolve, timeout); + let pin = select_biased! { + result = resolve => match result { + Ok(pin) => pin, + Err(error) + if error.kind() == NativeContinuationStoreErrorKind::Unavailable => + { + tracing::debug!(request_id = request_id.as_str(), %error, "Continuation affinity 查询失败,退化为外部续接"); + None + } + Err(error) + if error.kind() == NativeContinuationStoreErrorKind::OwnershipMismatch => + { + return Err(GatewayError::new(GatewayErrorKind::PolicyDenied, "Continuation does not belong to this client API key.")); + } + Err(error) => { + tracing::warn!(request_id = request_id.as_str(), %error, "Continuation affinity 记录无效,已拒绝续接"); + return Err(GatewayError::new(GatewayErrorKind::Internal, "Continuation state is invalid.")); + } + }, + _ = timeout => None, + }; + Some(match pin { + Some(pin) if !pin.matches_client(request.client.policy.key_id()) => { + return Err(GatewayError::new(GatewayErrorKind::PolicyDenied, "Continuation does not belong to this client API key.")); + } + Some(pin) if !authorization.account_scope.allows(pin.account()) => { + return Err(GatewayError::new(GatewayErrorKind::PolicyDenied, "Continuation account is outside the client account scope.")); + } + Some(pin) => ContinuationBinding::Pinned(pin), + None => ContinuationBinding::External(previous.clone()), + }) + } + None => None, + }; let account_scope = Arc::clone(&authorization.account_scope); let plan = match &request.target { ExecutionTarget::ProviderEndpoint { @@ -574,65 +616,66 @@ impl DefaultExecutionService { } } } - request.client.snapshot.plan( - &target_model, - &request.operation, - account_scope, - &target_context, - ) + let pin = continuation.as_ref().and_then(ContinuationBinding::pinned); + let extension_route = ModelRouteScope { + client_api_key: request.client.policy.key_id(), + account_groups: &account_group_ids, + extensions: &authorization.extension_scope, + model: public_model.as_str(), + }; + let direct = request.client.snapshot + .available_provider_kinds(&account_scope, &target_context) + .find_map(|kind| { + let provider = self.providers.get(kind)?; + let previous = pin.filter(|pin| pin.provider() == kind) + .and_then(NativeContinuationPin::session_state); + let model = provider.direct_account_model( + &target_model, + &request.operation, + previous, + request.client.snapshot.settings(), + )?; + middleware.as_ref() + .is_none_or(|plan| plan.preserves_model_bindings(extension_route, kind, &model)) + .then(|| (kind.clone(), model)) + }); + if let Some((kind, model)) = direct { + let account_scope = match authorization.required_account.as_ref() { + Some(id) => Arc::new(account_scope.restricted_to(&Default::default(), &[id.clone()].into())), + None => account_scope, + }; + request.client.snapshot.plan_with_direct_account_model( + &target_model, + &request.operation, + account_scope, + &target_context, + DirectAccountModel { + provider: &kind, + model: &model, + continuation_owner: pin.map(NativeContinuationPin::account), + }, + |account| upstream_adapters.as_ref().is_none_or(|plan| { + plan.uses_native_upstream(extension_route, &kind, account) + }), + ) + } else { + request.client.snapshot.plan( + &target_model, + &request.operation, + account_scope, + &target_context, + ) + } } } .map_err(map_routing_error)?; - let continuation = match request.metadata.previous_response_id.as_ref() { - Some(previous) => { - let resolve = self - .continuation - .resolve(request.client.policy.key_id(), previous) - .fuse(); - let timeout = Delay::new(COORDINATION_TIMEOUT).fuse(); - pin_mut!(resolve, timeout); - let pin = select_biased! { - result = resolve => match result { - Ok(pin) => pin, - Err(error) - if error.kind() == NativeContinuationStoreErrorKind::Unavailable => - { - tracing::debug!(request_id = request_id.as_str(), %error, "Continuation affinity 查询失败,退化为外部续接"); - None - } - Err(error) - if error.kind() == NativeContinuationStoreErrorKind::OwnershipMismatch => - { - return Err(GatewayError::new(GatewayErrorKind::PolicyDenied, "Continuation does not belong to this client API key.")); - } - Err(error) => { - tracing::warn!(request_id = request_id.as_str(), %error, "Continuation affinity 记录无效,已拒绝续接"); - return Err(GatewayError::new(GatewayErrorKind::Internal, "Continuation state is invalid.")); - } - }, - _ = timeout => None, - }; - Some(match pin { - Some(pin) if !pin.matches_client(request.client.policy.key_id()) => { - return Err(GatewayError::new(GatewayErrorKind::PolicyDenied, "Continuation does not belong to this client API key.")); - } - Some(pin) if !authorization.account_scope.allows(pin.account()) => { - return Err(GatewayError::new(GatewayErrorKind::PolicyDenied, "Continuation account is outside the client account scope.")); - } - Some(pin) - if !plan.candidates().iter().any(|candidate| candidate.provider() == pin.provider()) => - { - return Err(GatewayError::new(GatewayErrorKind::NoAvailableProvider, "Continuation provider is not available.")); - } - Some(pin) => { - attach_continuation_session_state(&mut request.operation, &pin); - ContinuationBinding::Pinned(pin) - } - None => ContinuationBinding::External(previous.clone()), - }) + if let Some(pin) = continuation.as_ref().and_then(ContinuationBinding::pinned) { + if !plan.candidates().iter().any(|candidate| candidate.provider() == pin.provider() + && candidate.account_scope().allows(pin.account())) { + return Err(GatewayError::new(GatewayErrorKind::NoAvailableProvider, "Continuation provider is not available.")); } - None => None, - }; + attach_continuation_session_state(&mut request.operation, pin); + } if start_guard.is_none() { start_guard = Some( self.prepare_execution_start(&request, &request_id, &mut authorization) diff --git a/backend/crates/gateway-core/src/engine/middleware/plan.rs b/backend/crates/gateway-core/src/engine/middleware/plan.rs index 96f08e63a..12e24be18 100644 --- a/backend/crates/gateway-core/src/engine/middleware/plan.rs +++ b/backend/crates/gateway-core/src/engine/middleware/plan.rs @@ -9,6 +9,16 @@ use std::{fmt, sync::Arc}; /// 一个发布代次冻结的统一数据面中间件计划 pub trait MiddlewarePlan: Send + Sync + fmt::Debug { + /// 只在能证明模型变更保留所有已绑定处理器时允许原生模型替换。 + fn preserves_model_bindings( + &self, + _route: crate::engine::ModelRouteScope<'_>, + _provider: &crate::routing::ProviderKind, + _target: &crate::routing::UpstreamModelId, + ) -> bool { + false + } + fn has_outbound(&self, _context: &MiddlewareContext) -> bool { false } @@ -85,6 +95,16 @@ pub struct FrozenMiddlewarePlan { } impl FrozenMiddlewarePlan { + #[must_use] + pub fn preserves_model_bindings( + &self, + route: crate::engine::ModelRouteScope<'_>, + provider: &crate::routing::ProviderKind, + target: &crate::routing::UpstreamModelId, + ) -> bool { + self.plan.preserves_model_bindings(route, provider, target) + } + #[must_use] pub fn has_outbound(&self, context: &MiddlewareContext) -> bool { self.plan.has_outbound(context) diff --git a/backend/crates/gateway-core/src/engine/mod.rs b/backend/crates/gateway-core/src/engine/mod.rs index bc3c98682..48c57c373 100644 --- a/backend/crates/gateway-core/src/engine/mod.rs +++ b/backend/crates/gateway-core/src/engine/mod.rs @@ -285,6 +285,31 @@ impl ContinuationAttempt { } } +/// 插件模型绑定使用同一组 Key、分组、调用链与模型事实。 +#[derive(Clone, Copy)] +pub struct ModelRouteScope<'a> { + pub client_api_key: &'a crate::policy::ClientApiKeyId, + pub account_groups: &'a [crate::routing::AccountGroupId], + pub extensions: &'a extensions::ExtensionCallScope, + pub model: &'a str, +} + +impl<'a> ModelRouteScope<'a> { + fn for_attempt( + context: &'a AttemptContext, + upstream: &'a crate::routing::UpstreamModelId, + ) -> Self { + Self { + client_api_key: context.client_api_key_ref(), + account_groups: context.account_group_ids(), + extensions: context.extension_scope(), + model: context + .requested_model() + .map_or(upstream.as_str(), |model| model.as_str()), + } + } +} + /// Provider 每次执行可见的 request-local context #[derive(Debug, Clone)] pub struct RequestAttemptContext { @@ -295,6 +320,7 @@ pub struct RequestAttemptContext { pricing: Arc, request_profile: Option, fast_mode: FastMode, + openai_request_country: crate::account::OpenAiRequestCountry, request_location: Option, privacy: Option>, request_id: ModelRequestId, @@ -392,6 +418,15 @@ impl RequestAttemptContext { self } + #[must_use] + pub fn with_openai_request_country( + mut self, + country: crate::account::OpenAiRequestCountry, + ) -> Self { + self.openai_request_country = country; + self + } + #[must_use] pub fn with_request_location( mut self, @@ -413,6 +448,7 @@ impl RequestAttemptContext { request_profile: None, pricing: Arc::default(), fast_mode: FastMode::Default, + openai_request_country: Default::default(), request_location: None, privacy: None, timing_started_at: Instant::now(), @@ -605,7 +641,7 @@ impl AttemptContext { }); self.request.upstream_adapters.as_ref().map_or( Ok(upstream_adapter::UpstreamAdapterSelection::Native), - |plan| plan.select(self, provider, model, account), + |plan| plan.select(ModelRouteScope::for_attempt(self, model), provider, account), ) } @@ -620,7 +656,11 @@ impl AttemptContext { .upstream_adapters .as_ref() .map_or(Ok(None), |plan| { - match plan.select(self, provider, model, Some(account))? { + match plan.select( + ModelRouteScope::for_attempt(self, model), + provider, + Some(account), + )? { upstream_adapter::UpstreamAdapterSelection::Native => Ok(None), upstream_adapter::UpstreamAdapterSelection::Adapter(adapter) => { Ok(Some(adapter)) @@ -685,6 +725,11 @@ impl AttemptContext { self.request.request_location.as_ref() } + #[must_use] + pub const fn openai_request_country(&self) -> &crate::account::OpenAiRequestCountry { + &self.request.openai_request_country + } + /// 当前 attempt 的诊断关联;克隆后可传给后台 transport 任务 #[must_use] pub fn trace(&self) -> crate::diagnostics::TraceContext { diff --git a/backend/crates/gateway-core/src/engine/provider.rs b/backend/crates/gateway-core/src/engine/provider.rs index e2bf6615e..11bff5d55 100644 --- a/backend/crates/gateway-core/src/engine/provider.rs +++ b/backend/crates/gateway-core/src/engine/provider.rs @@ -1174,6 +1174,17 @@ pub trait Provider: Send + Sync { false } + /// 请求身份明确时,Provider 可以为自身直连账号声明实际模型。Core 按该模型鉴权并冻结重试范围。 + fn direct_account_model( + &self, + _model: &PublicModelId, + _operation: &Operation, + _previous: Option<&crate::operation::ProviderSessionState>, + _settings: &crate::settings::SettingsValues, + ) -> Option { + None + } + /// Provider 解释自己的隐私规则,Core 仅冻结编译结果 fn compile_privacy_policy( &self, diff --git a/backend/crates/gateway-core/src/engine/upstream_adapter.rs b/backend/crates/gateway-core/src/engine/upstream_adapter.rs index 43518f5bf..477f8d5f3 100644 --- a/backend/crates/gateway-core/src/engine/upstream_adapter.rs +++ b/backend/crates/gateway-core/src/engine/upstream_adapter.rs @@ -14,12 +14,11 @@ use crate::{ identity::ProviderKind, metering::{CalculatedCost, Usage}, operation::Operation, - routing::UpstreamModelId, routing::extensions::ExtensionSetReference, }; use super::{ - AttemptContext, + AttemptContext, ModelRouteScope, middleware::MiddlewareHeader, provider::{EventStream, ProviderCallMetadata}, }; @@ -28,9 +27,8 @@ use super::{ pub trait UpstreamAdapterPlan: fmt::Debug + Send + Sync { fn select( &self, - context: &AttemptContext, + context: ModelRouteScope<'_>, provider: &ProviderKind, - model: &UpstreamModelId, account: Option<&ProviderAccountId>, ) -> Result; } @@ -62,14 +60,27 @@ impl FrozenUpstreamAdapterPlan { } } - pub(super) fn select( + /// 只有已确认为原生执行的账号可用于原生模型替换;命中但不可用的适配器保留其拒绝语义。 + #[must_use] + pub fn uses_native_upstream( &self, - context: &AttemptContext, + route: ModelRouteScope<'_>, + provider: &ProviderKind, + account: &ProviderAccountId, + ) -> bool { + matches!( + self.select(route, provider, Some(account)), + Ok(UpstreamAdapterSelection::Native) + ) + } + + pub(crate) fn select( + &self, + context: ModelRouteScope<'_>, provider: &ProviderKind, - model: &UpstreamModelId, account: Option<&ProviderAccountId>, ) -> Result { - self.plan.select(context, provider, model, account) + self.plan.select(context, provider, account) } } diff --git a/backend/crates/gateway-core/src/routing/mod.rs b/backend/crates/gateway-core/src/routing/mod.rs index d9252dc55..33a4012b9 100644 --- a/backend/crates/gateway-core/src/routing/mod.rs +++ b/backend/crates/gateway-core/src/routing/mod.rs @@ -532,16 +532,30 @@ pub struct RoutingContext { pub blocked_providers: BTreeSet, } +/// 直连模型及首次原生续接必须使用的账号 +pub struct DirectAccountModel<'a> { + pub provider: &'a ProviderKind, + pub model: &'a UpstreamModelId, + pub continuation_owner: Option<&'a crate::account::ProviderAccountId>, +} + /// 已绑定 Provider 的请求候选;模型端点携带真实上游模型,原生端点不虚构模型 #[derive(Debug, Clone, PartialEq, Eq)] pub struct ProviderCandidate { provider: ProviderKind, + requires_direct_authentication: bool, upstream_model: Option, emulated_features: BTreeSet, account_scope: Arc, } impl ProviderCandidate { + /// 模型按直连账号身份选择,Provider 必须在发送前核对实际凭据。 + #[must_use] + pub const fn requires_direct_authentication(&self) -> bool { + self.requires_direct_authentication + } + #[must_use] pub const fn provider(&self) -> &ProviderKind { &self.provider @@ -571,6 +585,7 @@ pub struct RoutingPlan { request_body_limit: usize, max_retry_after: std::time::Duration, pricing: Arc, + openai_request_country: crate::account::OpenAiRequestCountry, request_location: Option, privacy: Option>, config_revision: ConfigRevision, @@ -625,6 +640,11 @@ impl RoutingPlan { self.request_location.as_ref() } + #[must_use] + pub const fn openai_request_country(&self) -> &crate::account::OpenAiRequestCountry { + &self.openai_request_country + } + #[must_use] pub const fn config_revision(&self) -> ConfigRevision { self.config_revision diff --git a/backend/crates/gateway-core/src/routing/snapshot.rs b/backend/crates/gateway-core/src/routing/snapshot.rs index d53c090d1..6c42f7f93 100644 --- a/backend/crates/gateway-core/src/routing/snapshot.rs +++ b/backend/crates/gateway-core/src/routing/snapshot.rs @@ -17,10 +17,10 @@ use crate::settings::{SettingsValues, compiled::CompiledSettings}; use crate::validation::RoutingError; use super::{ - AccountGroupId, ClientRoutingScope, ConfigRevision, FrozenAccountScope, ModelCapabilities, - ProviderCandidate, ProviderCatalogGeneration, ProviderCatalogPort, ProviderKind, ProviderModel, - PublicModelId, RoutingContext, RoutingGroupSnapshot, RoutingPlan, RuntimeAccount, - RuntimeAccountDirectory, UpstreamModelId, + AccountGroupId, ClientRoutingScope, ConfigRevision, DirectAccountModel, FrozenAccountScope, + ModelCapabilities, ProviderCandidate, ProviderCatalogGeneration, ProviderCatalogPort, + ProviderKind, ProviderModel, PublicModelId, RoutingContext, RoutingGroupSnapshot, RoutingPlan, + RuntimeAccount, RuntimeAccountDirectory, UpstreamModelId, }; const MAXIMUM_SNAPSHOT_STABILITY_ATTEMPTS: usize = 4; @@ -1288,21 +1288,26 @@ impl RuntimeSnapshot { account_scope: &FrozenAccountScope, context: &RoutingContext, ) -> BTreeSet { - account_scope - .provider_kinds() - .iter() - .filter(|provider| { - self.providers.contains(*provider) - && context - .required_provider - .as_ref() - .is_none_or(|required| required == *provider) - && !context.blocked_providers.contains(*provider) - }) + self.available_provider_kinds(account_scope, context) .cloned() .collect() } + pub(crate) fn available_provider_kinds<'a>( + &'a self, + account_scope: &'a FrozenAccountScope, + context: &'a RoutingContext, + ) -> impl Iterator { + account_scope.provider_kinds().iter().filter(|provider| { + self.providers.contains(*provider) + && context + .required_provider + .as_ref() + .is_none_or(|required| required == *provider) + && !context.blocked_providers.contains(*provider) + }) + } + #[must_use] pub fn min_codex_client_versions(&self) -> &CodexClientMinVersions { &self.settings.min_codex_client_versions @@ -1315,7 +1320,67 @@ impl RuntimeSnapshot { account_scope: Arc, context: &RoutingContext, ) -> Result { - self.plan_inner(public_model, operation, account_scope, context, true) + self.plan_inner(public_model, operation, account_scope, context, true, None) + } + + /// 按实际目标分别校验目录、分组和账号。选中直连或常规路径后,重试沿用同一份计划。 + pub fn plan_with_direct_account_model( + &self, + public_model: &PublicModelId, + operation: &Operation, + scope: Arc, + context: &RoutingContext, + direct: DirectAccountModel<'_>, + uses_native_upstream: impl Fn(&ProviderAccountId) -> bool, + ) -> Result { + let DirectAccountModel { + provider, + model: target, + continuation_owner, + } = direct; + if self.model_alias(public_model.as_str()).is_some() + || self + .settings + .values + .model_mappings + .contains_key(public_model.as_str()) + { + return self.plan(public_model, operation, scope, context); + } + // 自动替换必须有原生目录依据;未替换的账号仍使用普通请求的路由合同。 + let sources = self + .model_catalog_accounts + .get(provider) + .and_then(|models| models.get(target.as_str())); + let direct_accounts = scope + .allowed_account_ids() + .filter(|id| { + scope.directory().account(id).is_some_and(|account| { + account.provider_kind() == provider && account.is_direct_account() + }) && scope.allows_model(id, target.as_str()) + && sources.is_none_or(|accounts| accounts.contains(*id)) + && uses_native_upstream(id) + }) + .cloned() + .collect::>(); + // 原生续接先用原账号,容量恢复仍可在同模型的授权账号间换号 + if !direct_accounts.is_empty() + && continuation_owner.is_none_or(|owner| direct_accounts.contains(owner)) + && let Ok(plan) = self.plan_inner( + public_model, + operation, + Arc::new( + scope.restricted_to(&BTreeSet::from([provider.clone()]), &direct_accounts), + ), + context, + true, + Some(target), + ) + { + return Ok(plan); + } + // 只有尚未开始任何 attempt 的请求才可保留原模型;两个模型从不进入同一重试计划。 + self.plan(public_model, operation, scope, context) } /// 管理探测已固定目标账号,不使用数据面 Key 的账号模型政策裁决探测资格 @@ -1331,7 +1396,14 @@ impl RuntimeSnapshot { .as_ref() .clone() .with_request_profiles(self.settings().request_profiles().clone()); - self.plan_inner(public_model, operation, Arc::new(scope), context, false) + self.plan_inner( + public_model, + operation, + Arc::new(scope), + context, + false, + None, + ) } fn plan_inner( @@ -1341,6 +1413,7 @@ impl RuntimeSnapshot { account_scope: Arc, context: &RoutingContext, enforce_account_model_policy: bool, + direct_model: Option<&UpstreamModelId>, ) -> Result { let requirements = operation.capability_requirements(); let mut candidates = Vec::new(); @@ -1350,19 +1423,23 @@ impl RuntimeSnapshot { } let requested_model = public_model.as_str(); - let mapped_model = self.mapped_model(requested_model); - let upstream_model = if self - .settings - .values - .model_mappings - .contains_key(requested_model) - || self.model_alias(requested_model).is_some() - { - UpstreamModelId::new(mapped_model) + let upstream_model = if let Some(direct) = direct_model { + direct.clone() } else { - UpstreamModelId::from_client_wire(mapped_model) - } - .map_err(|_| RoutingError::InvalidIdentifier)?; + let mapped_model = self.mapped_model(requested_model); + if self + .settings + .values + .model_mappings + .contains_key(requested_model) + || self.model_alias(requested_model).is_some() + { + UpstreamModelId::new(mapped_model) + } else { + UpstreamModelId::from_client_wire(mapped_model) + } + .map_err(|_| RoutingError::InvalidIdentifier)? + }; if enforce_account_model_policy && account_scope.groups_deny_model(Some(upstream_model.as_str())) { @@ -1383,9 +1460,10 @@ impl RuntimeSnapshot { if !self.providers.contains(provider) { continue; } - if self - .model_alias(public_model.as_str()) - .is_some_and(|alias| &alias.provider != provider) + if direct_model.is_none() + && self + .model_alias(public_model.as_str()) + .is_some_and(|alias| &alias.provider != provider) { continue; } @@ -1407,10 +1485,18 @@ impl RuntimeSnapshot { .provider_models .get(provider) .and_then(|models| models.get(&upstream_model)); + // 直连模型需要原生能力,不能借用插件为同名模型声明的账号与能力。 + if direct_model.is_some() && capabilities.is_none() { + continue; + } let contributions: Vec<_> = self .contributed_models() .iter() - .filter(|model| &model.provider == provider && &model.id == public_model) + .filter(|model| { + direct_model.is_none() + && &model.provider == provider + && &model.id == public_model + }) .collect(); let mut candidate_scope = Arc::clone(&account_scope); let emulated_features = if contributions.is_empty() { @@ -1467,6 +1553,7 @@ impl RuntimeSnapshot { native.unwrap_or_default() }; candidates.push(ProviderCandidate { + requires_direct_authentication: direct_model.is_some(), provider: provider.clone(), upstream_model: Some(upstream_model.clone()), emulated_features, @@ -1507,6 +1594,7 @@ impl RuntimeSnapshot { )), config_revision: self.revision, pricing: Arc::clone(&self.settings.values.pricing), + openai_request_country: self.settings.values.openai_request_country().clone(), request_location: self.settings.request_location.clone(), privacy: self.settings.privacy.clone(), account_error_protection: Arc::clone(&self.settings.account_error_protection), @@ -1584,6 +1672,7 @@ impl RuntimeSnapshot { }); } let candidate = ProviderCandidate { + requires_direct_authentication: false, provider: provider.clone(), upstream_model: upstream_model.cloned(), emulated_features: BTreeSet::new(), @@ -1596,6 +1685,7 @@ impl RuntimeSnapshot { )), config_revision: self.revision, pricing: Arc::clone(&self.settings.values.pricing), + openai_request_country: self.settings.values.openai_request_country().clone(), request_location: self.settings.request_location.clone(), privacy: self.settings.privacy.clone(), account_error_protection: Arc::clone(&self.settings.account_error_protection), diff --git a/backend/crates/gateway-core/src/settings/compiled.rs b/backend/crates/gateway-core/src/settings/compiled.rs index bf2dbcac7..5ff34c022 100644 --- a/backend/crates/gateway-core/src/settings/compiled.rs +++ b/backend/crates/gateway-core/src/settings/compiled.rs @@ -111,6 +111,10 @@ impl CompiledSettings { max_waiting: settings.max_waiting_per_key, timeout: Duration::from_secs(u64::from(settings.key_queue_timeout_seconds)), }; + settings + .openai_request_country + .validate() + .map_err(|_| InvalidSettings)?; let request_location = settings .request_location_enabled .then(|| settings.request_location.clone().normalized()) diff --git a/backend/crates/gateway-core/src/settings/mod.rs b/backend/crates/gateway-core/src/settings/mod.rs index a1c4e6ed6..7af89f821 100644 --- a/backend/crates/gateway-core/src/settings/mod.rs +++ b/backend/crates/gateway-core/src/settings/mod.rs @@ -5,7 +5,8 @@ pub mod privacy; pub mod request_profiles; mod values; pub use values::{ - SettingsValues, client_min_versions, response_body_limit, validate_request_limits, + SettingsValues, client_min_versions, default_oauth_guardian_review_model, response_body_limit, + validate_request_limits, }; #[derive(Debug, thiserror::Error)] diff --git a/backend/crates/gateway-core/src/settings/values.rs b/backend/crates/gateway-core/src/settings/values.rs index ce40450ee..b1d54fe28 100644 --- a/backend/crates/gateway-core/src/settings/values.rs +++ b/backend/crates/gateway-core/src/settings/values.rs @@ -25,6 +25,10 @@ pub struct SettingsValues { pub(crate) switch_account_on_queue_failure: bool, pub(crate) max_retry_after_seconds: u32, pub(crate) openai_guardian_reserved_concurrency: u32, + #[serde(default = "default_oauth_guardian_review_model")] + pub(crate) openai_oauth_guardian_review_model: bool, + #[serde(default)] + pub(crate) openai_request_country: crate::account::OpenAiRequestCountry, pub(crate) openai_account_affinity: crate::account::AccountAffinity, pub(crate) max_account_rotations: u32, pub(crate) openai_session_affinity_ttl_hours: u32, @@ -42,6 +46,10 @@ fn initial_protection_revision() -> u64 { 1 } +pub const fn default_oauth_guardian_review_model() -> bool { + true +} + impl SettingsValues { #[must_use] pub const fn with_account_error_protection_revision(mut self, revision: u64) -> Self { @@ -108,6 +116,31 @@ impl SettingsValues { self } + #[must_use] + pub const fn with_openai_oauth_guardian_review_model(mut self, enabled: bool) -> Self { + self.openai_oauth_guardian_review_model = enabled; + self + } + + #[must_use] + pub const fn openai_oauth_guardian_review_model(&self) -> bool { + self.openai_oauth_guardian_review_model + } + + #[must_use] + pub fn with_openai_request_country( + mut self, + policy: crate::account::OpenAiRequestCountry, + ) -> Self { + self.openai_request_country = policy; + self + } + + #[must_use] + pub fn openai_request_country(&self) -> &crate::account::OpenAiRequestCountry { + &self.openai_request_country + } + #[must_use] pub fn request_profiles(&self) -> &BTreeMap { &self.request_profiles @@ -207,6 +240,8 @@ impl SettingsValues { switch_account_on_queue_failure: false, max_retry_after_seconds: 240, openai_guardian_reserved_concurrency: 0, + openai_oauth_guardian_review_model: default_oauth_guardian_review_model(), + openai_request_country: Default::default(), openai_account_affinity: crate::account::AccountAffinity::default(), max_account_rotations: 3, openai_session_affinity_ttl_hours: 24, diff --git a/backend/crates/gateway-core/tests/engine/extensions.rs b/backend/crates/gateway-core/tests/engine/extensions.rs index 2afa34a03..60a194927 100644 --- a/backend/crates/gateway-core/tests/engine/extensions.rs +++ b/backend/crates/gateway-core/tests/engine/extensions.rs @@ -28,9 +28,8 @@ struct EmptyAdapterPlan; impl UpstreamAdapterPlan for EmptyAdapterPlan { fn select( &self, - _: &AttemptContext, + _: gateway_core::engine::ModelRouteScope<'_>, _: &ProviderKind, - _: &UpstreamModelId, _: Option<&gateway_core::account::ProviderAccountId>, ) -> Result { Ok(UpstreamAdapterSelection::Native) @@ -97,9 +96,8 @@ struct AccountSelectionProbe(std::sync::Mutex>>); impl UpstreamAdapterPlan for AccountSelectionProbe { fn select( &self, - _: &AttemptContext, + _: gateway_core::engine::ModelRouteScope<'_>, _: &ProviderKind, - _: &UpstreamModelId, account: Option<&gateway_core::account::ProviderAccountId>, ) -> Result { self.0 diff --git a/backend/crates/gateway-core/tests/routing/snapshot.rs b/backend/crates/gateway-core/tests/routing/snapshot.rs index 604441169..f351b452f 100644 --- a/backend/crates/gateway-core/tests/routing/snapshot.rs +++ b/backend/crates/gateway-core/tests/routing/snapshot.rs @@ -1772,9 +1772,9 @@ fn revision(value: u64) -> ConfigRevision { #[test] fn global_request_location_should_be_frozen_when_snapshot_is_published() { - use gateway_core::account::{ProviderAccountId, RequestLocation}; + use gateway_core::account::{OpenAiRequestCountry, ProviderAccountId, RequestLocation}; use gateway_core::runtime::RuntimeSnapshotHandle; - let make_snapshot = |version, timezone: &str, enabled| { + let make_snapshot = |version, timezone: &str, enabled, country| { let location = RequestLocation { timezone: timezone.parse().unwrap(), ..RequestLocation::default() @@ -1783,7 +1783,8 @@ fn global_request_location_should_be_frozen_when_snapshot_is_published() { revision(version), revision(version), SettingsValues::new(3, "smart", BTreeMap::new(), None, None) - .with_request_location(location, enabled), + .with_request_location(location, enabled) + .with_openai_request_country(country), Vec::new(), Vec::new(), vec![SnapshotProviderAccountFacts::new( @@ -1801,7 +1802,12 @@ fn global_request_location_should_be_frozen_when_snapshot_is_published() { ) .unwrap() }; - let handle = RuntimeSnapshotHandle::new(make_snapshot(1, "Asia/Tokyo", true)); + let handle = RuntimeSnapshotHandle::new(make_snapshot( + 1, + "Asia/Tokyo", + true, + OpenAiRequestCountry::Passthrough {}, + )); let frozen = handle.acquire().unwrap(); let plan = |snapshot: &gateway_core::routing::RuntimeSnapshot| { snapshot @@ -1814,7 +1820,20 @@ fn global_request_location_should_be_frozen_when_snapshot_is_published() { .unwrap() }; let old_plan = plan(&frozen); - handle.publish(make_snapshot(2, "America/New_York", true)); + handle.publish(make_snapshot( + 2, + "America/New_York", + true, + OpenAiRequestCountry::FollowLocation {}, + )); + assert_eq!( + old_plan.openai_request_country(), + &OpenAiRequestCountry::Passthrough {} + ); + assert_eq!( + plan(&handle.acquire().unwrap()).openai_request_country(), + &OpenAiRequestCountry::FollowLocation {} + ); assert_eq!( old_plan.request_location().unwrap().timezone.name(), "Asia/Tokyo" @@ -1831,7 +1850,7 @@ fn global_request_location_should_be_frozen_when_snapshot_is_published() { .name(), "America/New_York" ); - handle.publish(make_snapshot(3, "Asia/Tokyo", false)); + handle.publish(make_snapshot(3, "Asia/Tokyo", false, Default::default())); assert!( plan(&handle.acquire().unwrap()) .request_location() @@ -1841,7 +1860,7 @@ fn global_request_location_should_be_frozen_when_snapshot_is_published() { old_plan.request_location().unwrap().timezone.name(), "Asia/Tokyo" ); - handle.publish(make_snapshot(4, "Asia/Tokyo", true)); + handle.publish(make_snapshot(4, "Asia/Tokyo", true, Default::default())); assert_eq!( plan(&handle.acquire().unwrap()) .request_location() @@ -2167,3 +2186,223 @@ fn key_profiles_replace_whole_global_choice_and_previous_snapshot_stays_frozen() assert_eq!(values(&previous), ["global-a", "override"]); assert_eq!(values(&build("global-b", false)), ["global-b", "global-b"]); } + +#[test] +fn direct_reviewer_model_freezes_only_authorized_native_catalog_accounts() { + use gateway_core::account::{AccountModelAccess, AccountModelAccessMode, ProviderAccountId}; + const TARGET: &str = "codex-auto-review"; + const LUNA: &str = "gpt-5.6-luna"; + struct Catalog; + impl ProviderCatalogPort for Catalog { + fn is_direct_account(&self, _: &ProviderKind, kind: &str) -> bool { + kind == "oauth" + } + fn catalog_generations(&self) -> BTreeMap { + [( + ProviderKind::new("openai").unwrap(), + ProviderCatalogGeneration::new(1), + )] + .into() + } + fn query_model_capabilities( + &self, + _: &ProviderKind, + ) -> BoxFuture<'_, Result, ProviderCatalogUnavailable>> + { + Box::pin(async { + Ok(vec![ + ProviderModelCapabilities::new( + UpstreamModelId::new(TARGET).unwrap(), + super::capabilities(), + ) + .with_catalog_accounts( + [ + "acct_oauth", + "acct_oauth_backup", + "acct_denied", + "acct_blocked", + "acct_key", + ] + .map(|id| ProviderAccountId::new(id).unwrap()) + .into(), + ), + ProviderModelCapabilities::new( + UpstreamModelId::new(LUNA).unwrap(), + super::capabilities(), + ), + ]) + }) + } + } + let facts = SnapshotFacts::new( + revision(1), + revision(1), + super::settings(), + vec![], + vec![], + [ + "acct_oauth", + "acct_oauth_backup", + "acct_denied", + "acct_blocked", + "acct_unpublished", + "acct_key", + ] + .map(|id| { + let account = + SnapshotProviderAccountFacts::new(ProviderAccountId::new(id).unwrap(), "openai") + .with_authentication_kind( + if id == "acct_key" { "api_key" } else { "oauth" }.into(), + ); + if matches!(id, "acct_denied" | "acct_blocked") { + let allowed = if id == "acct_denied" { + LUNA + } else { + "unrelated-model" + }; + account.with_model_access( + AccountModelAccess::new( + AccountModelAccessMode::Allowlist, + vec![allowed.into()], + ) + .unwrap(), + ) + } else { + account + } + }) + .into(), + vec![], + ); + let snapshot = block_on( + RuntimeSnapshotCompiler::new( + Arc::new(TestSnapshotStore::new(Ok(facts))), + Arc::new(Catalog), + ) + .compile(), + ) + .unwrap(); + let snapshot = snapshot.with_extensions(Some(ExtensionSetReference::new( + ExtensionSetId::new("review-catalog".into()).unwrap(), + Arc::new(ModelLease(vec![gateway_core::routing::ContributedModel { + owner: "review-plugin".into(), + id: PublicModelId::new(TARGET).unwrap(), + provider: ProviderKind::new("openai").unwrap(), + accounts: ["acct_oauth", "acct_unpublished"] + .map(|id| ProviderAccountId::new(id).unwrap()) + .into(), + capabilities: super::capabilities(), + presentation: ModelPresentation::new(Some("Review".into()), None), + }])), + ))); + let plan = |fixed: Option<&str>, owner: Option<&str>, adapter_account: Option<&str>| { + let scope = snapshot.all_account_scope(); + let provider = ProviderKind::new("openai").unwrap(); + let target = UpstreamModelId::new(TARGET).unwrap(); + let fixed = fixed.map(|id| ProviderAccountId::new(id).unwrap()); + let owner = owner.map(|id| ProviderAccountId::new(id).unwrap()); + let scope = match fixed { + Some(id) => Arc::new(scope.restricted_to(&Default::default(), &[id].into())), + None => scope, + }; + snapshot.plan_with_direct_account_model( + &PublicModelId::new(LUNA).unwrap(), + &super::operation(), + scope, + &Default::default(), + gateway_core::routing::DirectAccountModel { + provider: &provider, + model: &target, + continuation_owner: owner.as_ref(), + }, + |id| Some(id.as_str()) != adapter_account, + ) + }; + let oauth_accounts = &["acct_oauth", "acct_oauth_backup"][..]; + for (fixed, owner, expected_model, expected_accounts) in [ + (None, None, TARGET, oauth_accounts), + (None, Some("acct_oauth"), TARGET, oauth_accounts), + (Some("acct_oauth"), None, TARGET, &["acct_oauth"][..]), + (Some("acct_key"), None, LUNA, &["acct_key"][..]), + ( + None, + Some("acct_key"), + LUNA, + &[ + "acct_oauth", + "acct_oauth_backup", + "acct_denied", + "acct_unpublished", + "acct_key", + ][..], + ), + ] { + let frozen = plan(fixed, owner, None).unwrap(); + assert_eq!( + frozen.candidates().len(), + 1, + "retry must retain the selected model" + ); + let candidate = &frozen.candidates()[0]; + assert_eq!( + candidate.requires_direct_authentication(), + expected_model == TARGET + ); + assert_eq!(candidate.upstream_model().unwrap().as_str(), expected_model); + for id in [ + "acct_key", + "acct_oauth", + "acct_oauth_backup", + "acct_denied", + "acct_unpublished", + "acct_blocked", + ] { + assert_eq!( + candidate + .account_scope() + .allows_model(&ProviderAccountId::new(id).unwrap(), expected_model), + expected_accounts.contains(&id) + ); + } + } + for id in ["acct_denied", "acct_unpublished"] { + let preserved = plan(Some(id), None, None).unwrap(); + let candidate = &preserved.candidates()[0]; + assert_eq!(candidate.upstream_model().unwrap().as_str(), LUNA); + assert!( + candidate + .account_scope() + .allows_model(&ProviderAccountId::new(id).unwrap(), LUNA) + ); + } + assert!(plan(Some("acct_blocked"), None, None).is_err()); + let adapter_plan = plan(None, Some("acct_oauth"), Some("acct_oauth")).unwrap(); + assert_eq!( + adapter_plan.candidates()[0] + .upstream_model() + .unwrap() + .as_str(), + LUNA + ); + let settings = snapshot + .settings() + .clone() + .with_model_mappings([(LUNA.into(), "custom".into())].into()); + let configured = snapshot.with_settings(&settings).unwrap(); + let configured_plan = configured.plan_with_direct_account_model( + &PublicModelId::new(LUNA).unwrap(), + &super::operation(), + configured.all_account_scope(), + &Default::default(), + gateway_core::routing::DirectAccountModel { + provider: &ProviderKind::new("openai").unwrap(), + model: &UpstreamModelId::new(TARGET).unwrap(), + continuation_owner: None, + }, + |_| true, + ); + assert!( + configured_plan.is_err(), + "an explicit mapping to an unavailable model must not be bypassed" + ); +} diff --git a/backend/crates/gateway-plugin/runtime/src/adapter/middleware/execution.rs b/backend/crates/gateway-plugin/runtime/src/adapter/middleware/execution.rs index b1060debd..198a0e03b 100644 --- a/backend/crates/gateway-plugin/runtime/src/adapter/middleware/execution.rs +++ b/backend/crates/gateway-plugin/runtime/src/adapter/middleware/execution.rs @@ -49,6 +49,31 @@ impl PluginMiddlewarePlan { } impl MiddlewarePlan for PluginMiddlewarePlan { + fn preserves_model_bindings( + &self, + route: gateway_core::engine::ModelRouteScope<'_>, + provider: &gateway_core::routing::ProviderKind, + target: &gateway_core::routing::UpstreamModelId, + ) -> bool { + [MiddlewareMount::Attempt, MiddlewareMount::Outbound] + .iter() + .filter_map(|mount| self.middleware.get(mount)) + .flatten() + .all(|entry| { + let matches = |model| { + entry.scope.matches_processing( + route.client_api_key, + route.account_groups, + Some(provider), + Some(model), + ) + }; + route.extensions.contains(&entry.instance_id) + || !matches(route.model) + || matches(target.as_str()) + }) + } + fn has_outbound(&self, context: &MiddlewareContext) -> bool { self.middleware .get(&MiddlewareMount::Outbound) diff --git a/backend/crates/gateway-plugin/runtime/src/adapter/upstream_adapter/mod.rs b/backend/crates/gateway-plugin/runtime/src/adapter/upstream_adapter/mod.rs index 8e3e023bf..61fadf460 100644 --- a/backend/crates/gateway-plugin/runtime/src/adapter/upstream_adapter/mod.rs +++ b/backend/crates/gateway-plugin/runtime/src/adapter/upstream_adapter/mod.rs @@ -11,16 +11,12 @@ use std::{fmt, sync::Arc}; use gateway_core::{ account::ProviderAccountId, - engine::{ - AttemptContext, - upstream_adapter::{ - UpstreamAdapter, UpstreamAdapterInvocation, UpstreamAdapterPlan, - UpstreamAdapterSelection, - }, + engine::ModelRouteScope, + engine::upstream_adapter::{ + UpstreamAdapter, UpstreamAdapterInvocation, UpstreamAdapterPlan, UpstreamAdapterSelection, }, error::{ProviderError, ProviderErrorKind}, identity::ProviderKind, - routing::UpstreamModelId, upstream::UpstreamSendState, }; use gateway_plugin_sdk::call::upstream_adapter::UpstreamAdapterDeclaration; @@ -117,19 +113,16 @@ impl fmt::Debug for PluginUpstreamAdapterPlan { impl UpstreamAdapterPlan for PluginUpstreamAdapterPlan { fn select( &self, - context: &AttemptContext, + context: ModelRouteScope<'_>, provider: &ProviderKind, - model: &UpstreamModelId, account: Option<&ProviderAccountId>, ) -> Result { - let model = context - .requested_model() - .map_or(model.as_str(), |model| model.as_str()); + let model = context.model; for entry in &self.entries { - if context.extension_scope().contains(&entry.instance_id) + if context.extensions.contains(&entry.instance_id) || !entry.scope.matches_processing( - context.client_api_key_ref(), - context.account_group_ids(), + context.client_api_key, + context.account_groups, Some(provider), Some(model), ) diff --git a/backend/crates/gateway-plugin/runtime/tests/generation/policy/outbound.rs b/backend/crates/gateway-plugin/runtime/tests/generation/policy/outbound.rs index 108def7fd..85c818365 100644 --- a/backend/crates/gateway-plugin/runtime/tests/generation/policy/outbound.rs +++ b/backend/crates/gateway-plugin/runtime/tests/generation/policy/outbound.rs @@ -342,3 +342,64 @@ impl Drop for NotifyOnDrop { } } } + +#[tokio::test] +async fn automatic_model_substitution_keeps_attempt_and_outbound_middleware_bindings() { + use gateway_core::engine::ModelRouteScope; + for stage in ["attempt", "outbound"] { + let instances = [ + ("instance-exact", "key-exact", vec!["gpt-5.6-luna".into()]), + ("instance-wildcard", "key-wildcard", vec![]), + ( + "instance-both", + "key-both", + vec!["gpt-5.6-luna".into(), "codex-auto-review".into()], + ), + ] + .map(|(id, key, models)| { + let mut entry = instance(id, 0, serde_json::json!({})); + entry.bindings[0].stage = stage.into(); + entry.bindings[0].models = models; + entry.bindings[0].client_key_ids = vec![key.into()]; + entry + }) + .into(); + let (cache, runtime) = if stage == "outbound" { + runtime(instances, RpcLimits::default()).await + } else { + super::setup(instances).await + }; + let generation = prepare(&runtime).await; + let plan = runtime + .execution_registry() + .middleware(&generation) + .unwrap(); + for (key, preserved) in [ + ("key-exact", false), + ("key-wildcard", true), + ("key-both", true), + ("key-other", true), + ] { + let key = ClientApiKeyId::new(key).unwrap(); + let route = ModelRouteScope { + client_api_key: &key, + account_groups: &[], + extensions: &Default::default(), + model: "gpt-5.6-luna", + }; + assert_eq!( + plan.preserves_model_bindings( + route, + &ProviderKind::new("openai").unwrap(), + &gateway_core::routing::UpstreamModelId::new("codex-auto-review").unwrap() + ), + preserved, + "{stage}" + ); + } + drop(plan); + drop(generation); + runtime.shutdown().await; + super::super::wait_until_empty(cache.path()).await; + } +} diff --git a/backend/crates/gateway-plugin/runtime/tests/generation/upstream_adapter.rs b/backend/crates/gateway-plugin/runtime/tests/generation/upstream_adapter.rs index 0e093fd2b..933962684 100644 --- a/backend/crates/gateway-plugin/runtime/tests/generation/upstream_adapter.rs +++ b/backend/crates/gateway-plugin/runtime/tests/generation/upstream_adapter.rs @@ -243,6 +243,56 @@ fn execute_with_context( }) } +#[tokio::test] +async fn native_model_eligibility_respects_explicit_upstream_adapter_bindings() { + use gateway_core::engine::ModelRouteScope; + for models in [json!(["gpt-5.6-luna"]), json!([])] { + let wildcard = models.as_array().unwrap().is_empty(); + let mut config = configuration("https://example.invalid", false); + let entry = &mut config["upstream_registration"]["adapters"][0]; + entry["models"] = models; + entry["account_ids"] = json!(["acct_one"]); + let (cache, store, runtime) = setup(config).await; + store.snapshot.lock().unwrap().instances[0].bindings[0].client_key_ids = + vec!["key-one".into()]; + let generation = + ExtensionPreparationPort::prepare(&runtime, ConfigRevision::new(1).unwrap()) + .await + .unwrap(); + let plan = runtime + .execution_registry() + .upstream_adapters(&generation) + .unwrap(); + let provider = ProviderKind::new("openai").unwrap(); + for (key, account, model, native) in [ + ("key-one", "acct_one", "gpt-5.6-luna", false), + ("key-one", "acct_one", "codex-auto-review", !wildcard), + ("key-two", "acct_one", "gpt-5.6-luna", true), + ("key-one", "acct_two", "gpt-5.6-luna", true), + ] { + let key = ClientApiKeyId::new(key).unwrap(); + let route = ModelRouteScope { + client_api_key: &key, + account_groups: &[], + extensions: &Default::default(), + model, + }; + assert_eq!( + plan.uses_native_upstream( + route, + &provider, + &ProviderAccountId::new(account).unwrap() + ), + native + ); + } + drop(plan); + drop(generation); + runtime.shutdown().await; + super::wait_until_empty(cache.path()).await; + } +} + #[tokio::test] async fn account_scoped_preselection_keeps_fallback_failures_within_matching_accounts() { for fallback_first in [false, true] { diff --git a/backend/crates/gateway-plugin/sdk/src/call/services/settings.rs b/backend/crates/gateway-plugin/sdk/src/call/services/settings.rs index 914699059..02e01c6f7 100644 --- a/backend/crates/gateway-plugin/sdk/src/call/services/settings.rs +++ b/backend/crates/gateway-plugin/sdk/src/call/services/settings.rs @@ -15,6 +15,9 @@ pub type Revision = NonZeroU64; pub type RotationStrategy = String; pub type AccountAffinity = String; pub type PricingOverrides = BTreeMap>; +fn default_oauth_guardian_review_model() -> bool { + true +} #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "camelCase", deny_unknown_fields)] pub struct AccountErrorProtection { @@ -136,6 +139,10 @@ pub struct PrivacyPreviewResult { #[derive(Clone, Serialize, Deserialize)] #[serde(deny_unknown_fields)] pub struct RuntimeSettings { + #[serde(default = "default_oauth_guardian_review_model")] + pub openai_oauth_guardian_review_model: bool, + #[serde(default)] + pub openai_request_country: OpenAiRequestCountry, pub codex_privacy_policy: CodexPrivacyPolicy, pub request_location_enabled: bool, pub request_location: RequestLocation, @@ -177,6 +184,11 @@ pub struct RuntimeSettings { #[derive(Clone, Serialize, Deserialize)] #[serde(deny_unknown_fields)] pub struct ReplaceRuntimeSettings { + /// 旧客户端缺少此字段时保留已保存的审核模型策略 + #[serde(default, skip_serializing_if = "Option::is_none")] + pub openai_oauth_guardian_review_model: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub openai_request_country: Option, pub codex_privacy_policy: CodexPrivacyPolicy, pub request_location_enabled: bool, pub request_location: RequestLocation, @@ -249,6 +261,14 @@ pub struct RequestLocation { pub city: String, pub timezone: String, } +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +#[serde(tag = "mode", rename_all = "snake_case", deny_unknown_fields)] +pub enum OpenAiRequestCountry { + Default {}, + Passthrough {}, + FollowLocation {}, + Custom { country: String }, +} #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] #[serde(rename_all = "camelCase", deny_unknown_fields)] pub struct SmartSchedulingConfig { @@ -314,6 +334,11 @@ pub struct UpdatePricing { pub models: Vec, pub change: PricingChange, } +impl Default for OpenAiRequestCountry { + fn default() -> Self { + Self::FollowLocation {} + } +} pub struct Load; impl Operation for Load { const NAME: &'static str = "settings.load"; @@ -389,6 +414,8 @@ impl Operation for PreviewClientProfile { impl From for ReplaceRuntimeSettings { fn from(settings: RuntimeSettings) -> Self { Self { + openai_oauth_guardian_review_model: Some(settings.openai_oauth_guardian_review_model), + openai_request_country: Some(settings.openai_request_country), codex_privacy_policy: settings.codex_privacy_policy, request_location_enabled: settings.request_location_enabled, request_location: settings.request_location, diff --git a/backend/crates/gateway-protocol/src/openai/guardian.rs b/backend/crates/gateway-protocol/src/openai/guardian.rs new file mode 100644 index 000000000..1cfa806cd --- /dev/null +++ b/backend/crates/gateway-protocol/src/openai/guardian.rs @@ -0,0 +1,230 @@ +//! 在 Responses 入站身份字段合并前识别 Guardian 的三种调用 + +use serde::{Deserialize, Deserializer}; +use serde_json::{Map, Value}; + +const CONTEXT_KEY: &str = "codex_guardian_identity"; +/// Codex 原生 OAuth 同步审核使用的专用模型 +pub const CODEX_AUTO_REVIEW_MODEL: &str = "codex-auto-review"; + +/// 当前 Responses 请求的 Codex Guardian 调用类型 +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CodexGuardianRole { + Reviewer, + Classifier, + Housekeeper, +} + +impl CodexGuardianRole { + /// 该调用在原生 OAuth 上游使用的角色头值 + #[must_use] + pub fn header(self) -> Option<&'static str> { + match self { + Self::Reviewer => Some("reviewer"), + Self::Classifier => Some("classifier"), + Self::Housekeeper => None, + } + } + + /// 分类器和后台整理器用各自的 sampler 选择 WebSocket 或 HTTP + #[must_use] + pub fn uses_sampler_transport(self) -> bool { + matches!(self, Self::Classifier | Self::Housekeeper) + } +} + +#[derive(Clone, Copy, PartialEq, Eq)] +enum Identity { + Role(CodexGuardianRole), + Incomplete, + Other, + Ambiguous, +} + +impl Identity { + fn label(self) -> &'static str { + match self { + Self::Role(CodexGuardianRole::Reviewer) => "reviewer", + Self::Role(CodexGuardianRole::Classifier) => "classifier", + Self::Role(CodexGuardianRole::Housekeeper) => "housekeeper", + Self::Incomplete => "incomplete", + Self::Other => "other", + Self::Ambiguous => "ambiguous", + } + } +} + +struct Source<'a> { + subagent: Option<&'a str>, + turn: Turn, +} + +#[derive(Default, Deserialize)] +struct Turn { + #[serde(default, deserialize_with = "present_string")] + thread_source: Option, + #[serde(default, deserialize_with = "present_string")] + turn_trigger: Option, +} + +// 区分缺失与错误类型;serde 对重复出现的身份字段也会拒绝 +fn present_string<'de, D: Deserializer<'de>>(d: D) -> Result, D::Error> { + String::deserialize(d).map(Some) +} + +impl<'a> Source<'a> { + fn new(subagent: Option<&'a str>, turn: Option<&str>) -> Option { + let turn = match turn { + Some(raw) if raw.trim_start().starts_with('{') => serde_json::from_str(raw).ok()?, + Some(_) => return None, + None => Turn::default(), + }; + Some(Self { subagent, turn }) + } + + fn conflicts_with(&self, other: &Self) -> bool { + [ + self.subagent.zip(other.subagent), + self.turn + .thread_source + .as_deref() + .zip(other.turn.thread_source.as_deref()), + self.turn + .turn_trigger + .as_deref() + .zip(other.turn.turn_trigger.as_deref()), + ] + .into_iter() + .flatten() + .any(|(left, right)| left != right) + } + + fn identity(&self) -> Identity { + let source = self.turn.thread_source.as_deref(); + let trigger = self.turn.turn_trigger.as_deref(); + if self.subagent.is_some_and(|v| v != "guardian") { + return Identity::Other; + } + let role = match (source, trigger) { + (Some("guardian_review"), Some("guardian_classifier" | "guardian_housekeeper")) + | (Some("guardian_classifier"), Some("guardian_review" | "guardian_housekeeper")) => { + return Identity::Ambiguous; + } + (Some("guardian_review"), _) => CodexGuardianRole::Reviewer, + (Some("guardian_classifier"), _) => CodexGuardianRole::Classifier, + (None, Some("guardian_housekeeper")) => CodexGuardianRole::Housekeeper, + (Some(_), _) => return Identity::Other, + _ => return Identity::Incomplete, + }; + if self.subagent.is_some() { + Identity::Role(role) + } else { + Identity::Incomplete + } + } +} + +fn identity(body: &Map, context: &Map) -> Identity { + let metadata = body.get("client_metadata"); + let body_subagent = metadata.and_then(|m| m.get("x-openai-subagent")); + let websocket = context + .get(super::WEBSOCKET_FRAME_CONTEXT_KEY) + .and_then(Value::as_bool) + == Some(true); + let header_subagent = (!websocket) + .then(|| context.get("subagent")) + .flatten() + .and_then(Value::as_str); + if metadata.is_some_and(|m| !m.is_object()) || body_subagent.is_some_and(|v| !v.is_string()) { + return Identity::Ambiguous; + } + if body_subagent.and_then(Value::as_str) != Some("guardian") + && header_subagent != Some("guardian") + { + return if body_subagent.is_some() || header_subagent.is_some() { + Identity::Other + } else { + Identity::Incomplete + }; + } + let turn = metadata.and_then(|m| m.get("x-codex-turn-metadata")); + if turn.is_some_and(|v| !v.is_string()) { + return Identity::Ambiguous; + } + let Some(body) = Source::new( + body_subagent.and_then(Value::as_str), + turn.and_then(Value::as_str), + ) else { + return Identity::Ambiguous; + }; + if websocket { + return body.identity(); + } + let Some(header) = Source::new( + header_subagent, + context.get("turn_metadata").and_then(Value::as_str), + ) else { + return Identity::Ambiguous; + }; + if body.conflicts_with(&header) { + return Identity::Ambiguous; + } + match (body.identity(), header.identity()) { + (Identity::Ambiguous, _) | (_, Identity::Ambiguous) => Identity::Ambiguous, + (Identity::Incomplete, header) => header, + (body, _) => body, + } +} + +/// WS 只使用本帧正文;HTTP 两侧须各自完整,不能拼接彼此欠缺的身份字段 +pub fn capture_codex_guardian_identity( + body: &Map, + context: &mut Map, + guardian_header: Option<&str>, + ambiguous_headers: bool, +) { + if guardian_header.is_none() + && !ambiguous_headers + && context.get("subagent").and_then(Value::as_str) != Some("guardian") + && body + .get("client_metadata") + .and_then(|m| m.get("x-openai-subagent")) + .and_then(Value::as_str) + != Some("guardian") + { + return; + } + let websocket = context + .get(super::WEBSOCKET_FRAME_CONTEXT_KEY) + .and_then(Value::as_bool) + == Some(true); + let mut found = identity(body, context); + if !websocket + && (ambiguous_headers + || matches!((guardian_header, found), + (Some(header), Identity::Role(role)) if role.header() != Some(header))) + { + found = Identity::Ambiguous; + } + context.insert(CONTEXT_KEY.into(), Value::from(found.label())); +} + +/// 使用解码阶段保存的原始身份;程序内构造的请求可以直接使用正文和当前请求上下文 +#[must_use] +pub fn codex_guardian_role( + body: &Map, + context: &Map, +) -> Option { + if let Some(prepared) = context.get(CONTEXT_KEY) { + return match prepared.as_str()? { + "reviewer" => Some(CodexGuardianRole::Reviewer), + "classifier" => Some(CodexGuardianRole::Classifier), + "housekeeper" => Some(CodexGuardianRole::Housekeeper), + _ => None, + }; + } + match identity(body, context) { + Identity::Role(role) => Some(role), + _ => None, + } +} diff --git a/backend/crates/gateway-protocol/src/openai/mod.rs b/backend/crates/gateway-protocol/src/openai/mod.rs index f9bd520d3..6ef104c9d 100644 --- a/backend/crates/gateway-protocol/src/openai/mod.rs +++ b/backend/crates/gateway-protocol/src/openai/mod.rs @@ -19,6 +19,7 @@ pub const X_OPENAI_MEMGEN_REQUEST_HEADER: &str = "x-openai-memgen-request"; pub mod codex; /// OpenAI/Codex 事件语义、用量与限流字段编解码 pub mod events; +mod guardian; mod headers; /// Server-Sent Events 帧的解析与编码 pub mod sse; @@ -30,6 +31,10 @@ pub use codex::{ codex_turn_id, context_turn_metadata, observed_turn_metadata, turn_metadata_session_id, turn_metadata_thread_id, turn_metadata_turn_id, }; +pub use guardian::{ + CODEX_AUTO_REVIEW_MODEL, CodexGuardianRole, capture_codex_guardian_identity, + codex_guardian_role, +}; pub use headers::{ is_transport_managed_request_header, parse_retry_after_seconds, response_header_is_forwardable, }; diff --git a/backend/crates/gateway-store/src/admin_adapter.rs b/backend/crates/gateway-store/src/admin_adapter.rs index 690816d3c..799267489 100644 --- a/backend/crates/gateway-store/src/admin_adapter.rs +++ b/backend/crates/gateway-store/src/admin_adapter.rs @@ -83,6 +83,8 @@ impl SettingsStore for AdminSettingsStoreAdapter { let replacement = postgres::ControlPlaneReplacement { expected_revision: store_revision(command.expected_revision)?, settings: postgres::RuntimeSettingsUpdate { + openai_oauth_guardian_review_model: command.openai_oauth_guardian_review_model, + openai_request_country: command.openai_request_country, request_profile_updates: command.request_profile_updates, rotation_strategy: command.rotation_strategy.as_str().to_owned(), model_mappings: store_model_mappings(command.model_mappings), @@ -108,6 +110,8 @@ impl SettingsStore for AdminSettingsStoreAdapter { "switch_account_on_queue_failure".to_owned(), "max_retry_after_seconds".to_owned(), "openai_guardian_reserved_concurrency".to_owned(), + "openai_oauth_guardian_review_model".to_owned(), + "openai_request_country".to_owned(), "openai_account_affinity".to_owned(), "max_account_rotations".to_owned(), "openai_session_affinity_ttl_hours".to_owned(), @@ -207,6 +211,8 @@ pub(crate) fn admin_runtime_settings( }) .collect::>()?; Ok(AdminRuntimeSettings { + openai_oauth_guardian_review_model: settings.openai_oauth_guardian_review_model, + openai_request_country: settings.openai_request_country, request_profiles: settings.request_profiles, config_revision: admin_revision(settings.config_revision)?, model_mappings, diff --git a/backend/crates/gateway-store/src/postgres/runtime_settings.rs b/backend/crates/gateway-store/src/postgres/runtime_settings.rs index 8d5ff18e8..befc08c99 100644 --- a/backend/crates/gateway-store/src/postgres/runtime_settings.rs +++ b/backend/crates/gateway-store/src/postgres/runtime_settings.rs @@ -20,6 +20,8 @@ use crate::{Revision, StoreError, StoreResult, postgres_unavailable}; #[derive(Clone, PartialEq, Eq)] pub struct RuntimeSettings { + pub openai_oauth_guardian_review_model: bool, + pub openai_request_country: gateway_core::account::OpenAiRequestCountry, pub values: RuntimeSettingsValues, pub request_profiles: BTreeMap, @@ -51,6 +53,8 @@ impl fmt::Debug for RuntimeSettings { #[derive(Clone)] pub struct RuntimeSettingsUpdate { + pub openai_oauth_guardian_review_model: Option, + pub openai_request_country: Option, pub values: RuntimeSettingsValues, pub request_profile_updates: BTreeMap< gateway_core::routing::ProviderKind, @@ -78,6 +82,10 @@ impl fmt::Debug for RuntimeSettingsUpdate { impl RuntimeSettingsUpdate { pub fn validate(&self) -> StoreResult<()> { if self.values.validate().is_err() + || self + .openai_request_country + .as_ref() + .is_some_and(|policy| policy.validate().is_err()) || gateway_admin::model::settings::validate_model_mappings( self.model_mappings .iter() @@ -155,7 +163,7 @@ pub(crate) async fn load_runtime_settings_from_pool(pool: &PgPool) -> StoreResul refresh_concurrency, max_concurrent_per_account, rotation_strategy, smart_scheduling_json, quota_reset_window_weights_json, model_mappings_json, usage_retention_days, ops_event_retention_days, audit_retention_days, min_codex_desktop_version, - min_codex_cli_version, updated_at, responses_max_decompressed_body_bytes, max_waiting_per_key, max_waiting_per_account, key_queue_timeout_seconds, account_queue_timeout_seconds, switch_account_on_queue_failure, max_retry_after_seconds, openai_guardian_reserved_concurrency, openai_account_affinity, max_account_rotations, openai_session_affinity_ttl_hours, + min_codex_cli_version, updated_at, responses_max_decompressed_body_bytes, max_waiting_per_key, max_waiting_per_account, key_queue_timeout_seconds, account_queue_timeout_seconds, switch_account_on_queue_failure, max_retry_after_seconds, openai_guardian_reserved_concurrency, openai_oauth_guardian_review_model, openai_request_country_json, openai_account_affinity, max_account_rotations, openai_session_affinity_ttl_hours, account_error_protection_json, account_error_protection_revision, account_warmup_enabled, account_warmup_cron, account_warmup_model, reset_credit_lead_minutes, reset_credit_max_weekly_remaining_percent, reset_credit_on_low_weekly_quota from runtime_settings where id = 1", @@ -335,7 +343,7 @@ pub(crate) async fn load_runtime_settings_in_transaction( refresh_concurrency, max_concurrent_per_account, rotation_strategy, smart_scheduling_json, quota_reset_window_weights_json, model_mappings_json, usage_retention_days, ops_event_retention_days, audit_retention_days, min_codex_desktop_version, - min_codex_cli_version, updated_at, responses_max_decompressed_body_bytes, max_waiting_per_key, max_waiting_per_account, key_queue_timeout_seconds, account_queue_timeout_seconds, switch_account_on_queue_failure, max_retry_after_seconds, openai_guardian_reserved_concurrency, openai_account_affinity, max_account_rotations, openai_session_affinity_ttl_hours, + min_codex_cli_version, updated_at, responses_max_decompressed_body_bytes, max_waiting_per_key, max_waiting_per_account, key_queue_timeout_seconds, account_queue_timeout_seconds, switch_account_on_queue_failure, max_retry_after_seconds, openai_guardian_reserved_concurrency, openai_oauth_guardian_review_model, openai_request_country_json, openai_account_affinity, max_account_rotations, openai_session_affinity_ttl_hours, account_error_protection_json, account_error_protection_revision, account_warmup_enabled, account_warmup_cron, account_warmup_model, reset_credit_lead_minutes, reset_credit_max_weekly_remaining_percent, reset_credit_on_low_weekly_quota from runtime_settings where id = 1", @@ -420,6 +428,8 @@ pub(crate) async fn update_runtime_settings_in_transaction( switch_account_on_queue_failure = $33, reset_credit_on_low_weekly_quota = $34, quota_reset_window_weights_json = $35, + openai_oauth_guardian_review_model = coalesce($36, openai_oauth_guardian_review_model), + openai_request_country_json = coalesce($37, openai_request_country_json), updated_at = now() where id = 1 returning config_revision", @@ -467,6 +477,8 @@ pub(crate) async fn update_runtime_settings_in_transaction( .bind(update.values.switch_account_on_queue_failure) .bind(update.values.reset_credit_on_low_weekly_quota) .bind(sqlx::types::Json(update.values.quota_reset_window_weights)) + .bind(update.openai_oauth_guardian_review_model) + .bind(update.openai_request_country.as_ref().map(sqlx::types::Json)) .fetch_optional(&mut **transaction) .await .map_err(|source| postgres_unavailable("update runtime settings in transaction", source))? @@ -560,6 +572,8 @@ struct RuntimeSettingsRow { switch_account_on_queue_failure: bool, max_retry_after_seconds: i64, openai_guardian_reserved_concurrency: i64, + openai_oauth_guardian_review_model: bool, + openai_request_country_json: sqlx::types::Json, openai_account_affinity: String, max_account_rotations: i64, openai_session_affinity_ttl_hours: i64, @@ -589,6 +603,8 @@ fn runtime_settings_from_row(row: RuntimeSettingsRow) -> StoreResult>>()?; Ok(RuntimeSettings { + openai_oauth_guardian_review_model: row.openai_oauth_guardian_review_model, + openai_request_country: row.openai_request_country_json.0, request_profiles, config_revision: Revision::new(to_u64(row.config_revision)?)?, account_error_protection_revision: Revision::new(to_u64( diff --git a/backend/crates/gateway-store/src/postgres/snapshot.rs b/backend/crates/gateway-store/src/postgres/snapshot.rs index a2936ef4a..23a04eefc 100644 --- a/backend/crates/gateway-store/src/postgres/snapshot.rs +++ b/backend/crates/gateway-store/src/postgres/snapshot.rs @@ -237,6 +237,8 @@ struct SnapshotSettingsRow { switch_account_on_queue_failure: bool, max_retry_after_seconds: i64, openai_guardian_reserved_concurrency: i64, + openai_oauth_guardian_review_model: bool, + openai_request_country_json: sqlx::types::Json, openai_account_affinity: String, max_account_rotations: i64, openai_session_affinity_ttl_hours: i64, @@ -253,7 +255,7 @@ async fn load_settings( transaction: &mut Transaction<'_, Postgres>, ) -> StoreResult<(Revision, SettingsValues)> { let row = sqlx::query_as::<_, SnapshotSettingsRow>( - "select config_revision, account_error_protection_revision, account_error_protection_json, max_concurrent_per_account, rotation_strategy, smart_scheduling_json, quota_reset_window_weights_json, model_mappings_json, min_codex_desktop_version, min_codex_cli_version, max_waiting_per_key, max_waiting_per_account, key_queue_timeout_seconds, account_queue_timeout_seconds, switch_account_on_queue_failure, max_retry_after_seconds, openai_guardian_reserved_concurrency, openai_account_affinity, max_account_rotations, openai_session_affinity_ttl_hours, request_location_json, request_location_enabled, codex_privacy_policy_json, responses_max_decompressed_body_bytes, provider_request_profiles_json, pricing_overrides_json, pricing_synced_json from runtime_settings where id = 1", + "select config_revision, account_error_protection_revision, account_error_protection_json, max_concurrent_per_account, rotation_strategy, smart_scheduling_json, quota_reset_window_weights_json, model_mappings_json, min_codex_desktop_version, min_codex_cli_version, max_waiting_per_key, max_waiting_per_account, key_queue_timeout_seconds, account_queue_timeout_seconds, switch_account_on_queue_failure, max_retry_after_seconds, openai_guardian_reserved_concurrency, openai_oauth_guardian_review_model, openai_request_country_json, openai_account_affinity, max_account_rotations, openai_session_affinity_ttl_hours, request_location_json, request_location_enabled, codex_privacy_policy_json, responses_max_decompressed_body_bytes, provider_request_profiles_json, pricing_overrides_json, pricing_synced_json from runtime_settings where id = 1", ) .fetch_optional(&mut **transaction) .await @@ -278,6 +280,8 @@ async fn load_settings( .with_openai_guardian_reserved_concurrency(to_u32( row.openai_guardian_reserved_concurrency, )?) + .with_openai_oauth_guardian_review_model(row.openai_oauth_guardian_review_model) + .with_openai_request_country(row.openai_request_country_json.0) .with_openai_account_affinity( gateway_core::account::AccountAffinity::parse(&row.openai_account_affinity) .ok_or_else(|| invalid("invalid account affinity"))?, diff --git a/backend/crates/gateway-store/tests/postgres/control_plane.rs b/backend/crates/gateway-store/tests/postgres/control_plane.rs index 53dd10cd4..b083ba509 100644 --- a/backend/crates/gateway-store/tests/postgres/control_plane.rs +++ b/backend/crates/gateway-store/tests/postgres/control_plane.rs @@ -38,8 +38,14 @@ async fn control_plane_replacement_commits_one_writer_per_revision_and_preserves created_at: Utc::now(), }, }; + let mut customized = replacement("first", 1800); + customized.settings.openai_oauth_guardian_review_model = Some(false); + customized.settings.openai_request_country = + Some(gateway_core::account::OpenAiRequestCountry::Custom { + country: "CA".into(), + }); let (first, second) = tokio::join!( - repository.replace_control_plane(replacement("first", 1800)), + repository.replace_control_plane(customized), repository.replace_control_plane(replacement("second", 7200)), ); let (saved, conflict) = match (first, second) { @@ -59,6 +65,11 @@ async fn control_plane_replacement_commits_one_writer_per_revision_and_preserves current.values.refresh_margin_seconds, saved.values.refresh_margin_seconds ); + assert_eq!( + current.openai_oauth_guardian_review_model, + saved.openai_oauth_guardian_review_model + ); + assert_eq!(current.openai_request_country, saved.openai_request_country); let audit_count: i64 = sqlx::query_scalar( "select count(*) from admin_audit_events where action = 'settings.replace'", ) @@ -89,7 +100,19 @@ async fn control_plane_replacement_commits_one_writer_per_revision_and_preserves .unwrap() .settings .config_revision; - repository.replace_control_plane(fresh).await.unwrap(); + let after_legacy_write = repository + .replace_control_plane(fresh) + .await + .unwrap() + .settings; + assert_eq!( + after_legacy_write.openai_oauth_guardian_review_model, + saved.openai_oauth_guardian_review_model + ); + assert_eq!( + after_legacy_write.openai_request_country, + saved.openai_request_country + ); assert_eq!( repository .load_control_plane() diff --git a/backend/crates/gateway-store/tests/postgres/runtime_settings.rs b/backend/crates/gateway-store/tests/postgres/runtime_settings.rs index e75c7781b..e290c2d88 100644 --- a/backend/crates/gateway-store/tests/postgres/runtime_settings.rs +++ b/backend/crates/gateway-store/tests/postgres/runtime_settings.rs @@ -15,6 +15,8 @@ fn enabled_protection() -> gateway_core::account::AccountErrorProtection { pub(super) fn settings_with_margin(refresh_margin_seconds: u64) -> RuntimeSettingsUpdate { RuntimeSettingsUpdate { + openai_oauth_guardian_review_model: None, + openai_request_country: None, request_profile_updates: BTreeMap::new(), rotation_strategy: "smart".to_owned(), model_mappings: BTreeMap::from([ @@ -571,6 +573,73 @@ async fn retry_after_limit_defaults_and_updates_reach_the_runtime_snapshot() { database.close().await; } +#[tokio::test] +async fn openai_request_settings_round_trip_into_snapshot_across_legacy_writes() { + use gateway_core::account::OpenAiRequestCountry; + use gateway_store::postgres::{PgRuntimeSnapshotRepository, RuntimeSnapshotRepository}; + let Some(database) = TestDatabase::create("openai_request_settings").await else { + return; + }; + let repository = PgRuntimeSettingsRepository::new(database.pool.clone()); + let snapshots = PgRuntimeSnapshotRepository::new(database.pool.clone()); + let initial = snapshots.load_runtime_snapshot().await.unwrap(); + assert!(initial.settings.openai_oauth_guardian_review_model()); + assert_eq!( + initial.settings.openai_request_country(), + &OpenAiRequestCountry::FollowLocation {} + ); + + for (enabled, country) in [ + ( + true, + OpenAiRequestCountry::Custom { + country: "CA".into(), + }, + ), + (true, OpenAiRequestCountry::FollowLocation {}), + (false, OpenAiRequestCountry::Passthrough {}), + (false, OpenAiRequestCountry::Default {}), + ] { + let update = RuntimeSettingsUpdate { + openai_oauth_guardian_review_model: Some(enabled), + openai_request_country: Some(country.clone()), + ..settings_with_margin(600) + }; + repository.update_runtime_settings(update).await.unwrap(); + let saved = repository.load_runtime_settings().await.unwrap(); + assert_eq!(saved.openai_oauth_guardian_review_model, enabled); + assert_eq!(saved.openai_request_country, country); + repository + .update_runtime_settings(settings_with_margin(900)) + .await + .unwrap(); + let snapshot = snapshots.load_runtime_snapshot().await.unwrap(); + assert_eq!( + snapshot.settings.openai_oauth_guardian_review_model(), + enabled + ); + assert_eq!(snapshot.settings.openai_request_country(), &country); + assert!(snapshot.config_revision > saved.config_revision); + } + for invalid in [ + serde_json::json!({"mode":"custom","country":"ca"}), + serde_json::json!({"mode":"custom","country":null}), + serde_json::json!({"mode":"custom","country":"CA","extra":1}), + serde_json::json!({"mode":"follow_location","country":"CA"}), + ] { + assert!( + sqlx::query( + "update runtime_settings set openai_request_country_json = $1 where id = 1" + ) + .bind(sqlx::types::Json(invalid)) + .execute(&database.pool) + .await + .is_err() + ); + } + database.close().await; +} + #[tokio::test] async fn concurrency_queue_settings_round_trip_into_the_runtime_snapshot() { use gateway_store::postgres::{PgRuntimeSnapshotRepository, RuntimeSnapshotRepository}; diff --git a/backend/crates/providers/openai/src/credential/catalog/mod.rs b/backend/crates/providers/openai/src/credential/catalog/mod.rs index 1f9a599a7..fef389324 100644 --- a/backend/crates/providers/openai/src/credential/catalog/mod.rs +++ b/backend/crates/providers/openai/src/credential/catalog/mod.rs @@ -701,12 +701,12 @@ impl CodexCredentialCatalogService { .authentication .authorization_header() .map_err(CredentialRepositoryError::from)?; - let mut client = client - .for_account(account) + let mut client = credential + .authentication + .model_client_for_account(client, account) .map_err(|error| CodexCredentialCatalogError::Upstream { detail: error.to_string(), - })? - .with_responses_api_base_url(credential.authentication.responses_api_base_url()); + })?; if let super::CodexRuntimeAuthentication::ApiKey(auth) = &credential.authentication && auth.configuration.protocol == super::ApiKeyProtocol::Messages { diff --git a/backend/crates/providers/openai/src/credential/codec.rs b/backend/crates/providers/openai/src/credential/codec.rs index 5be1ce99b..4c4c8e7b9 100644 --- a/backend/crates/providers/openai/src/credential/codec.rs +++ b/backend/crates/providers/openai/src/credential/codec.rs @@ -1,7 +1,8 @@ //! Codex 明文 credential JSON 的 schema 校验与日志脱敏边界 use super::api_key::ApiKeyAuthentication; -use gateway_core::account::PlaintextCredential; +use crate::transport::{CodexBackendClient, CodexClientResult}; +use gateway_core::account::{PlaintextCredential, ProviderAccount}; use secrecy::{ExposeSecret, SecretString}; use serde_json::Value; use thiserror::Error; @@ -53,12 +54,17 @@ impl CodexRuntimeAuthentication { } } - /// 传输只消费公开连接设置,不读取凭据枚举或秘密 - pub(crate) fn responses_api_base_url(&self) -> Option<&str> { - match self { - Self::ApiKey(auth) => Some(&auth.configuration.base_url), - Self::OAuth(_) => None, - } + /// 出口、API 地址与 OAuth 路由声明必须来自同一个被选账号 + pub(crate) fn model_client_for_account( + &self, + client: &CodexBackendClient, + account: &ProviderAccount, + ) -> CodexClientResult { + let client = client.for_account(account)?; + Ok(match self { + Self::ApiKey(auth) => client.with_responses_api_base_url(&auth.configuration.base_url), + Self::OAuth(secret) => client.with_fedramp_routing(secret.has_fedramp_routing_claim()), + }) } pub fn authorization_header(&self) -> Result { diff --git a/backend/crates/providers/openai/src/credential/quota/warmup.rs b/backend/crates/providers/openai/src/credential/quota/warmup.rs index 29e521856..23abe5038 100644 --- a/backend/crates/providers/openai/src/credential/quota/warmup.rs +++ b/backend/crates/providers/openai/src/credential/quota/warmup.rs @@ -249,7 +249,10 @@ impl CodexCredentialQuotaService { let upstream_request = CodexResponsesRequest::from_body(body); let request_id = format!("warmup_{}", Uuid::now_v7().simple()); - let client_for_account = match client.for_account(account) { + let client_for_account = match credential + .authentication + .model_client_for_account(client, account) + { Ok(c) => c, Err(error) => { tracing::warn!(account_id = %account.id(), error = %error, "warmup client for account failed"); diff --git a/backend/crates/providers/openai/src/credential/types.rs b/backend/crates/providers/openai/src/credential/types.rs index 2e6ec52d6..266f441da 100644 --- a/backend/crates/providers/openai/src/credential/types.rs +++ b/backend/crates/providers/openai/src/credential/types.rs @@ -32,6 +32,17 @@ pub struct CodexOAuthSecret { pub id_token: Option, } +impl CodexOAuthSecret { + /// 托管 OAuth 使用所选账号的 ID token;外部 ChatGPT token 可以只有 access token + pub(crate) fn has_fedramp_routing_claim(&self) -> bool { + let token = self.id_token.as_ref().unwrap_or(&self.access_token); + decode_jwt_payload::(token.expose_secret()) + .ok() + .and_then(|claims| claims.auth) + .is_some_and(|auth| auth.chatgpt_account_is_fedramp) + } +} + impl fmt::Debug for CodexOAuthSecret { fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { formatter @@ -168,8 +179,8 @@ struct AuthClaims { user_id: Option, #[serde(default)] chatgpt_account_id: Option, - #[serde(rename = "chatgpt_account_is_fedramp", default)] - _chatgpt_account_is_fedramp: bool, + #[serde(default)] + chatgpt_account_is_fedramp: bool, } /// 与官方 `codex_protocol::auth::PlanType` 同构的 claims 反序列化类型 diff --git a/backend/crates/providers/openai/src/provider/execution.rs b/backend/crates/providers/openai/src/provider/execution.rs index 7f468464f..8b5f44856 100644 --- a/backend/crates/providers/openai/src/provider/execution.rs +++ b/backend/crates/providers/openai/src/provider/execution.rs @@ -367,10 +367,10 @@ impl CodexProvider { }); let events = cold_json_response_stream(ColdJsonResponse { installation_id, - client: client - .for_account(lease.account()) + client: lease + .authentication() + .model_client_for_account(&client, lease.account()) .map_err(|error| map_client_error(error, UpstreamSendState::NotSent, None).error)? - .with_responses_api_base_url(lease.authentication().responses_api_base_url()) .with_middleware_headers(middleware_headers) .with_outbound_middleware(outbound_middleware) .with_privacy(context.privacy(), context.cancellation().clone()), @@ -446,6 +446,8 @@ pub(super) struct ColdJsonResponse { pub(super) struct OpenAiSessionState { pub(super) account_id: String, #[serde(default, skip_serializing_if = "Option::is_none")] + pub(super) reviewer_model: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] pub(super) credential_revision: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub(super) oauth_identity: Option, @@ -465,6 +467,7 @@ pub(super) enum OpenAiContinuationScope { pub(super) struct OpenAiSessionCapture { pub(super) account_id: String, + pub(super) reviewer_model: Option, pub(super) credential_revision: Option, pub(super) oauth_identity: Option, pub(super) conversation_id: Option, @@ -506,6 +509,7 @@ fn encode_openai_session_capture( }; encode_openai_session_state(OpenAiSessionState { account_id: capture.account_id.clone(), + reviewer_model: capture.reviewer_model.clone(), credential_revision: capture.credential_revision, oauth_identity: capture.oauth_identity.clone(), conversation_id: capture.conversation_id.clone(), @@ -997,6 +1001,7 @@ pub(super) fn cold_response_stream(response: ColdResponse) -> EventStream { } let response_transport = response.transport; let routing_affinity = response.routing_affinity; + let codex_oauth = matches!(lease.authentication(), crate::credential::CodexRuntimeAuthentication::OAuth(_)); let websocket_connection_id = response.websocket_connection_id; let mut body = response.body; let mut failure_diagnostics = response.diagnostics.clone(); @@ -1178,10 +1183,10 @@ pub(super) fn cold_response_stream(response: ColdResponse) -> EventStream { ) }); let timing_signals = decoder.take_timing_signals(); - if let Some(affinity) = &routing_affinity { + if codex_oauth { for fact in events.iter().flat_map(ProviderEvent::canonical_facts) { if let GatewayEvent::Started(meta) = fact { - guardian_routing.remember(context.client_api_key_ref(), &active_account, meta.response_id(), affinity); + guardian_routing.remember(context.client_api_key_ref(), &active_account, meta.response_id(), routing_affinity.as_ref()); } } } diff --git a/backend/crates/providers/openai/src/provider/guardian.rs b/backend/crates/providers/openai/src/provider/guardian.rs index aa5c7ca3c..f6ec61ccf 100644 --- a/backend/crates/providers/openai/src/provider/guardian.rs +++ b/backend/crates/providers/openai/src/provider/guardian.rs @@ -1,28 +1,85 @@ //! 按 Client Key 和账号关联父响应的连接路由快照,不持久化 Cookie 或改变选号 use std::{ - collections::HashMap, + num::NonZeroUsize, sync::{Arc, Mutex}, time::{Duration, Instant}, }; use gateway_core::{account::ProviderAccount, policy::ClientApiKeyId}; +use lru::LruCache; use sha2::{Digest, Sha256}; use crate::transport::routing_affinity::ChatGptRoutingAffinity; +use gateway_protocol::openai::CODEX_AUTO_REVIEW_MODEL; + +pub(super) fn review_model( + enabled: bool, + model: &gateway_core::routing::PublicModelId, + operation: &gateway_core::operation::Operation, + previous: Option<&gateway_core::operation::ProviderSessionState>, +) -> Option { + let gateway_core::operation::Operation::Generate(request) = operation else { + return None; + }; + let raw_model = request.protocol_payload().body().get("model")?.as_str()?; + if model.as_str() != raw_model || raw_model == CODEX_AUTO_REVIEW_MODEL || !is_reviewer(request) + { + return None; + } + // 已确认的续接沿用上一跳的实际模型,只有新审核使用本次请求冻结的设置 + let previous_model = previous + .and_then(|state| state.payload().get("reviewer_model")) + .and_then(serde_json::Value::as_str); + previous_model + .map_or(enabled, |previous| previous == CODEX_AUTO_REVIEW_MODEL) + .then(|| { + gateway_core::routing::UpstreamModelId::new(CODEX_AUTO_REVIEW_MODEL) + .expect("valid reviewer model") + }) +} + +pub(super) fn is_reviewer(request: &gateway_core::operation::GenerateRequest) -> bool { + use gateway_protocol::openai::{CodexGuardianRole, OPENAI_PROTOCOL, codex_guardian_role}; + let payload = request.protocol_payload(); + payload.protocol() == OPENAI_PROTOCOL + && codex_guardian_role(payload.body(), payload.context()) + == Some(CodexGuardianRole::Reviewer) +} + +pub(super) fn continuation_model_matches( + previous: Option<&str>, + next: &str, + direct_model: bool, +) -> bool { + // 外部及旧版记录没有已确认的审核模型,不能将其原生 handle 交给自动选择的目标 + previous.map_or(!direct_model, |previous| previous == next) +} + // 与连接续接 tombstone 使用相同保留窗口;最多 4096 份、每份两个 8 KiB Cookie const RETENTION: Duration = Duration::from_mins(30); const MAX_PARENT_RESPONSES: usize = 4096; -#[derive(Clone, Default)] +#[derive(Clone)] pub(super) struct GuardianRouting { - parents: Arc>>, + parents: Arc>>, } -struct ParentRouting { +#[derive(Clone)] +pub(super) struct ParentRouting { captured_at: Instant, - affinity: ChatGptRoutingAffinity, + pub(super) affinity: Option, +} + +impl Default for GuardianRouting { + fn default() -> Self { + Self { + parents: Arc::new(Mutex::new(LruCache::new( + NonZeroUsize::new(MAX_PARENT_RESPONSES).expect("positive parent limit"), + ))), + } + } } impl GuardianRouting { @@ -31,18 +88,18 @@ impl GuardianRouting { client_key: &ClientApiKeyId, account: &ProviderAccount, response_id: &str, - ) -> Option { + ) -> Option { let key = parent_key(client_key, account, response_id); let mut parents = self .parents .lock() .unwrap_or_else(std::sync::PoisonError::into_inner); - let parent = parents.get(&key)?; + let parent = parents.peek(&key)?; if parent.captured_at.elapsed() >= RETENTION { - parents.remove(&key); + parents.pop(&key); return None; } - Some(parent.affinity.clone()) + Some(parent.clone()) } pub(super) fn remember( @@ -50,32 +107,21 @@ impl GuardianRouting { client_key: &ClientApiKeyId, account: &ProviderAccount, response_id: &str, - affinity: &ChatGptRoutingAffinity, + affinity: Option<&ChatGptRoutingAffinity>, ) { let key = parent_key(client_key, account, response_id); let mut parents = self .parents .lock() .unwrap_or_else(std::sync::PoisonError::into_inner); - if parents.contains_key(&key) { + if parents.contains(&key) { return; } - if parents.len() >= MAX_PARENT_RESPONSES { - parents.retain(|_, parent| parent.captured_at.elapsed() < RETENTION); - if parents.len() >= MAX_PARENT_RESPONSES - && let Some(oldest) = parents - .iter() - .min_by_key(|(_, parent)| parent.captured_at) - .map(|(key, _)| *key) - { - parents.remove(&oldest); - } - } - parents.insert( + parents.put( key, ParentRouting { captured_at: Instant::now(), - affinity: affinity.clone(), + affinity: affinity.cloned(), }, ); } diff --git a/backend/crates/providers/openai/src/provider/live.rs b/backend/crates/providers/openai/src/provider/live.rs index 04584b6d9..96fc10c35 100644 --- a/backend/crates/providers/openai/src/provider/live.rs +++ b/backend/crates/providers/openai/src/provider/live.rs @@ -364,11 +364,13 @@ impl CodexProvider { .cloned() .collect::>(); let events = cold_live_call_stream(ColdLiveCall { - client: self - .client_for_request(&context, lease.account())? - .for_account(lease.account()) + client: lease + .authentication() + .model_client_for_account( + &self.client_for_request(&context, lease.account())?, + lease.account(), + ) .map_err(|error| map_client_error(error, UpstreamSendState::NotSent, None).error)? - .with_responses_api_base_url(lease.authentication().responses_api_base_url()) .with_middleware_headers(middleware_headers) .with_outbound_middleware(outbound_middleware), registry: Arc::clone(&self.live_registry), diff --git a/backend/crates/providers/openai/src/provider/mod.rs b/backend/crates/providers/openai/src/provider/mod.rs index 1650718b5..089fd1276 100644 --- a/backend/crates/providers/openai/src/provider/mod.rs +++ b/backend/crates/providers/openai/src/provider/mod.rs @@ -44,10 +44,10 @@ use gateway_core::task::{ WorkerRunnable, WorkerSchedule, WorkerTaskError, }; use gateway_core::upstream::{UpstreamSendState, UpstreamTransport}; -use gateway_protocol::openai::OPENAI_PROTOCOL; use gateway_protocol::openai::events::{ ParsedRateLimits, parse_rate_limit_headers, rate_limits_to_header_pairs, }; +use gateway_protocol::openai::{CodexGuardianRole, OPENAI_PROTOCOL, codex_guardian_role}; use reqwest::{Client, header::HeaderValue}; use secrecy::{ExposeSecret, SecretString}; use serde::{Deserialize, Serialize}; @@ -87,7 +87,7 @@ use crate::transport::protocol::responses::{ }; use crate::transport::request::{ CodexRequestEncodeError, RequestAccountScope, align_structured_location_fields, - encode_generate_request, scope_request_to_account, + encode_generate_payload, scope_request_to_account, }; use crate::transport::session::CodexSessionIdentity; use crate::transport::usage::normalize_service_tier; @@ -173,7 +173,19 @@ impl PreparedGenerateRequest { fn checked_native_continuation_scope( &self, context: &AttemptContext, + direct_model: bool, ) -> Result { + if self.continuation_requested + && !guardian::continuation_model_matches( + self.previous_session + .as_ref() + .and_then(|state| state.reviewer_model.as_deref()), + self.upstream.model(), + direct_model, + ) + { + return Err(continuation_replay_required_error("review_model_changed")); + } let pin = context.continuation().and_then(ContinuationBinding::pinned); let scope = match self .previous_session @@ -221,6 +233,7 @@ struct SelectedGenerate { lease: CodexCredentialLease, account_selection_wait_ms: u64, frozen_requirements: CapabilityRequirements, + direct_model: bool, } impl CodexProvider { @@ -404,6 +417,21 @@ impl Provider for CodexProvider { crate::credential::is_direct_account_kind(authentication_kind) } + fn direct_account_model( + &self, + model: &gateway_core::routing::PublicModelId, + operation: &Operation, + previous: Option<&ProviderSessionState>, + settings: &gateway_core::settings::SettingsValues, + ) -> Option { + guardian::review_model( + settings.openai_oauth_guardian_review_model(), + model, + operation, + previous, + ) + } + fn compile_privacy_policy( &self, policy: &gateway_core::settings::privacy::CodexPrivacyPolicy, @@ -492,7 +520,7 @@ impl Provider for CodexProvider { ..Default::default() }; }; - let Ok(encoded) = encode_generate_request(request, "observability", None) else { + let Ok(encoded) = encode_generate_payload(request, "observability") else { return ProviderRequestObservation::default(); }; let previous_reasoning_effort_override = request @@ -629,7 +657,7 @@ impl Provider for CodexProvider { } // 跨协议转换必须在选号后执行;选号前只按各自协议读取明确会话身份 let upstream = (generate.protocol_payload().protocol() == OPENAI_PROTOCOL) - .then(|| encode_generate_request(generate, upstream_model.as_str(), None)) + .then(|| encode_generate_payload(generate, upstream_model.as_str())) .transpose() .map_err(map_request_error)?; // 固定调度约束:Guardian 分类先于选号,不能随原生/适配器发送路径改变 @@ -644,11 +672,12 @@ impl Provider for CodexProvider { false, ) }); + let direct_model = candidate.requires_direct_authentication(); let preselection = upstream .filter(|_| !adapted) .map(|upstream| self.prepare_generate_request(generate, upstream, &context)); if let Some(prepared) = preselection.as_ref() { - prepared.checked_native_continuation_scope(&context)?; + prepared.checked_native_continuation_scope(&context, direct_model)?; } let cache_preference = preselection .as_ref() @@ -730,6 +759,14 @@ impl Provider for CodexProvider { }; let account_selection_wait_ms = u64::try_from(selection_started_at.elapsed().as_millis()).unwrap_or(u64::MAX); + // 账号可能在快照编译后轮换认证方式;专用审核目标不能发给新换入的 API Key。 + if direct_model + && !crate::credential::is_direct_account_kind(lease.account().authentication_kind()) + { + return Err(map_selection_error( + CredentialSelectionError::NoEligibleCredential, + )); + } if context.continuation_attempt() == ContinuationAttempt::RotateForClientReplay { // Core 已确认允许换号;选号器迁移共享绑定后,完整历史仍须由客户端提供 // 不将旧账号的 previous_response_id 或增量输入发送给替代账号 @@ -757,6 +794,13 @@ impl Provider for CodexProvider { let payload = generate.protocol_payload(); let mut operation = Operation::Generate(generate.clone()); if payload.protocol() == OPENAI_PROTOCOL + && !(adapter.is_none() + && matches!( + lease.authentication(), + crate::credential::CodexRuntimeAuthentication::OAuth(_) + ) + && codex_guardian_role(payload.body(), payload.context()) + == Some(CodexGuardianRole::Housekeeper)) && let Some(tier) = fast_policy_tier( context.fast_mode(), payload.body().get("service_tier").and_then(Value::as_str), @@ -813,6 +857,7 @@ impl Provider for CodexProvider { lease, account_selection_wait_ms, frozen_requirements, + direct_model, }, ) .await @@ -836,6 +881,7 @@ impl CodexProvider { mut lease, account_selection_wait_ms, frozen_requirements, + direct_model, } = selected; let Operation::Generate(generate) = operation else { return Err(provider_error( @@ -858,7 +904,7 @@ impl CodexProvider { "provider_input", None, ); - let mut upstream = encode_generate_request(&generate, upstream_model.as_str(), None) + let mut upstream = encode_generate_payload(&generate, upstream_model.as_str()) .map_err(map_request_error)?; gateway_protocol::anthropic::strip_foreign_reasoning_for_responses(upstream.body_mut()); upstream.client_account_follow_only = crate::request_identity::follows_session_with_headers( @@ -872,11 +918,17 @@ impl CodexProvider { &middleware_headers, ); let processed = self.prepare_generate_request(&generate, upstream, &context); - let native_scope = processed.checked_native_continuation_scope(&context)?; + let native_scope = processed.checked_native_continuation_scope(&context, direct_model)?; let mut upstream_request = processed.upstream; let session_transport_key = derive_codex_transport_key(&upstream_request, context.client_api_key_ref()); let previous_session = processed.previous_session; + let reviewer_model = (direct_model + || guardian::is_reviewer(&generate) + || previous_session + .as_ref() + .is_some_and(|state| state.reviewer_model.is_some())) + .then(|| upstream_model.as_str().to_owned()); let continuation_requested = processed.continuation_requested; if !context.is_diagnostic_required_account() { self.selector @@ -984,11 +1036,14 @@ impl CodexProvider { let state_before = trace .is_enabled() .then(|| crate::transport::diagnostics::evidence::request_state(&upstream_request)); + let codex_oauth = oauth_identity.is_some(); + let guardian_role = codex_oauth + .then(|| upstream_request.oauth_guardian_role(&middleware_headers)) + .flatten(); let guardian_parent = (!state_owner_cross_account - && upstream_request.is_guardian() && matches!( - lease.authentication(), - crate::credential::CodexRuntimeAuthentication::OAuth(_) + guardian_role, + Some(CodexGuardianRole::Reviewer | CodexGuardianRole::Classifier) )) .then(|| { upstream_request @@ -1010,14 +1065,19 @@ impl CodexProvider { ); scope_request_to_account(&mut upstream_request, &installation_id, account_scope); // 父响应的可信关联只恢复此字段,不把首次 Guardian 请求的其他账号状态视为可信 - if let Some((response_id, _)) = &guardian_parent + if guardian_role.is_some() && let Some(Value::Object(metadata)) = upstream_request.body_mut().get_mut("client_metadata") { - metadata.insert( - "parent_response_id".to_owned(), - Value::String(response_id.clone()), - ); + metadata.remove("guardian_credits_requested"); + if let Some((response_id, _)) = &guardian_parent { + metadata.insert( + "parent_response_id".to_owned(), + Value::String(response_id.clone()), + ); + } else { + metadata.remove("parent_response_id"); + } } if let Some(before) = state_before { trace.record_evidence("provider.request.account_scope", serde_json::json!({ @@ -1034,11 +1094,13 @@ impl CodexProvider { "after": crate::transport::diagnostics::evidence::request_state(&upstream_request), })); } - let codex_oauth = matches!( - lease.authentication(), - crate::credential::CodexRuntimeAuthentication::OAuth(_) - ); if codex_oauth { + if matches!( + guardian_role, + Some(CodexGuardianRole::Reviewer | CodexGuardianRole::Classifier) + ) { + upstream_request.body_mut().shift_remove("service_tier"); + } let responses_lite = upstream_request.responses_lite.as_deref() == Some("true"); crate::compat::normalize_selected_codex_downstream_body( upstream_request.body_mut(), @@ -1051,7 +1113,11 @@ impl CodexProvider { .account() .request_location() .or(context.request_location()); - align_structured_location_fields(upstream_request.body_mut(), location); + align_structured_location_fields( + upstream_request.body_mut(), + location, + context.openai_request_country(), + ); let requirement = transport_requirement(&upstream_request); let http_only = lease.transport() == crate::credential::ResponsesTransport::Http; if http_only && requirement.requires_websocket() { @@ -1063,7 +1129,7 @@ impl CodexProvider { let requested_transport = if http_only { CodexProviderTransport::HttpOnly } else { - selected_transport(&upstream_request) + selected_transport(&upstream_request, guardian_role) }; let session_http_fallback = requirement.allows_pre_send_http_fallback() && session_transport_key @@ -1115,6 +1181,7 @@ impl CodexProvider { let session_capture = (!continuation_requested || previous_session.is_some()).then(|| OpenAiSessionCapture { account_id: lease.account_id().as_str().to_owned(), + reviewer_model, oauth_identity, credential_revision: matches!( lease.authentication(), @@ -1143,11 +1210,15 @@ impl CodexProvider { }; let events = cold_response_stream(ColdResponse { installation_id, - client: client - .for_account(lease.account()) + client: lease + .authentication() + .model_client_for_account(&client, lease.account()) .map_err(|error| map_client_error(error, UpstreamSendState::NotSent, None).error)? - .with_responses_api_base_url(lease.authentication().responses_api_base_url()) - .with_routing_affinity(guardian_parent.map(|(_, affinity)| affinity)) + .with_routing_affinity( + guardian_parent + .filter(|_| guardian_role == Some(CodexGuardianRole::Reviewer)) + .and_then(|(_, parent)| parent.affinity), + ) .with_connection_budget(context.connection_budget().clone()) .with_middleware_headers(middleware_headers) .with_outbound_middleware(outbound_middleware) diff --git a/backend/crates/providers/openai/src/provider/observation.rs b/backend/crates/providers/openai/src/provider/observation.rs index c14dd3c91..20c2a7305 100644 --- a/backend/crates/providers/openai/src/provider/observation.rs +++ b/backend/crates/providers/openai/src/provider/observation.rs @@ -643,8 +643,16 @@ pub(super) fn codex_model_presentation(model: &CodexCatalogModel) -> ModelPresen .with_hidden(hidden) } -pub(super) fn selected_transport(request: &CodexResponsesRequest) -> CodexProviderTransport { - if request.force_http_sse { +pub(super) fn selected_transport( + request: &CodexResponsesRequest, + guardian_role: Option, +) -> CodexProviderTransport { + // 专用 sampler 的 HTTP 请求可能没有传输标记。显式 WS 和物理入站连接仍沿用原合同 + let dedicated_http = guardian_role.is_some_and(CodexGuardianRole::uses_sampler_transport) + && !request.use_websocket + && !request.websocket_frame + && request.downstream_websocket_connection_id.is_none(); + if request.force_http_sse || dedicated_http { CodexProviderTransport::HttpOnly } else { CodexProviderTransport::PreferWebSocket diff --git a/backend/crates/providers/openai/src/transport/client.rs b/backend/crates/providers/openai/src/transport/client.rs index a6bd31c7a..32b5ab5d1 100644 --- a/backend/crates/providers/openai/src/transport/client.rs +++ b/backend/crates/providers/openai/src/transport/client.rs @@ -43,7 +43,7 @@ use super::websocket::{ const UPSTREAM_CONNECT_TIMEOUT: Duration = Duration::from_secs(15); pub(super) const UPSTREAM_STREAM_IDLE_TIMEOUT: Duration = Duration::from_secs(5 * 60); -const X_CODEX_WS_STREAM_REQUEST_START_MS_CLIENT_METADATA_KEY: &str = +pub(super) const X_CODEX_WS_STREAM_REQUEST_START_MS_CLIENT_METADATA_KEY: &str = "x-codex-ws-stream-request-start-ms"; type ReqwestClientCacheKey = (Option, String, Duration); type ReqwestClientCache = Mutex>; @@ -699,6 +699,7 @@ pub struct CodexBackendClient { pub(super) base_url: String, pub(super) official_base_url: String, pub(super) protocol: OpenAiUpstreamProtocol, + pub(super) fedramp_routing: bool, pub(super) profile: CodexWireProfileState, pub(super) websocket_pool: Option>, pub(super) websocket_origin_breaker: WebSocketOriginBreaker, @@ -743,6 +744,7 @@ impl CodexBackendClient { base_url, official_base_url: super::endpoints::OFFICIAL_CODEX_BASE_URL.to_owned(), protocol: OpenAiUpstreamProtocol::Codex, + fedramp_routing: false, profile, websocket_pool: None, websocket_origin_breaker: WebSocketOriginBreaker::default(), @@ -852,21 +854,24 @@ impl CodexBackendClient { fallback.send().await.map_err(CodexClientError::HttpJson) } - pub(crate) fn with_responses_api_base_url(mut self, base_url: Option<&str>) -> Self { - if let Some(base_url) = base_url { - self.base_url = base_url.trim_end_matches('/').to_owned(); - self.protocol = OpenAiUpstreamProtocol::ResponsesApi; - self.websocket_origin_key = format!( - "{}:{}", - websocket_origin_key(&self.base_url), - self.egress_key - ); - } + pub(crate) fn with_fedramp_routing(mut self, enabled: bool) -> Self { + self.fedramp_routing = enabled; + self + } + + pub(crate) fn with_responses_api_base_url(mut self, base_url: &str) -> Self { + self.base_url = base_url.trim_end_matches('/').to_owned(); + self.protocol = OpenAiUpstreamProtocol::ResponsesApi; + self.websocket_origin_key = format!( + "{}:{}", + websocket_origin_key(&self.base_url), + self.egress_key + ); self } pub(crate) fn with_messages_api_base_url(self, base_url: &str) -> Self { - let mut client = self.with_responses_api_base_url(Some(base_url)); + let mut client = self.with_responses_api_base_url(base_url); client.protocol = OpenAiUpstreamProtocol::MessagesApi; client } @@ -876,6 +881,7 @@ impl CodexBackendClient { account: &gateway_core::account::ProviderAccount, ) -> Result { let mut client = self.clone(); + client.fedramp_routing = false; client.outbound_proxy = account.outbound_proxy().cloned(); client.egress_key = egress_key(account.id().as_str(), account.outbound_proxy()); if account.authentication_kind() == crate::CODEX_AUTHENTICATION_KIND_API_KEY { @@ -1085,7 +1091,10 @@ pub(super) async fn http_json_upstream_error( // 请求辅助函数 // --------------------------------------------------------------------------- -pub(super) fn websocket_upstream_request(request: &CodexResponsesRequest) -> CodexResponsesRequest { +pub(super) fn websocket_upstream_request( + request: &CodexResponsesRequest, + start_ms: &str, +) -> CodexResponsesRequest { let mut request = request.clone(); // 上游通过流式事件执行,下游仍按客户端原来的偏好返回响应 if !request.stream() { @@ -1093,11 +1102,11 @@ pub(super) fn websocket_upstream_request(request: &CodexResponsesRequest) -> Cod .body_mut() .insert("stream".to_owned(), Value::Bool(true)); } - project_websocket_client_metadata(&mut request); + project_websocket_client_metadata(&mut request, start_ms); request } -fn project_websocket_client_metadata(request: &mut CodexResponsesRequest) { +fn project_websocket_client_metadata(request: &mut CodexResponsesRequest, start_ms: &str) { let mut metadata = match request.client_metadata() { Some(Value::Object(metadata)) => metadata.clone(), None => Map::new(), @@ -1122,12 +1131,12 @@ fn project_websocket_client_metadata(request: &mut CodexResponsesRequest) { } metadata.insert( X_CODEX_WS_STREAM_REQUEST_START_MS_CLIENT_METADATA_KEY.to_string(), - Value::String(now_unix_timestamp_millis().to_string()), + Value::String(start_ms.to_owned()), ); request.set_client_metadata(Some(Value::Object(metadata))); } -fn now_unix_timestamp_millis() -> u128 { +pub(super) fn now_unix_timestamp_millis() -> u128 { SystemTime::now() .duration_since(UNIX_EPOCH) .map(|duration| duration.as_millis()) diff --git a/backend/crates/providers/openai/src/transport/client_stream.rs b/backend/crates/providers/openai/src/transport/client_stream.rs index f5025c7b7..276859fa8 100644 --- a/backend/crates/providers/openai/src/transport/client_stream.rs +++ b/backend/crates/providers/openai/src/transport/client_stream.rs @@ -9,7 +9,7 @@ use std::{ use futures::{StreamExt, TryStreamExt}; use gateway_protocol::openai::{ - X_OPENAI_MEMGEN_REQUEST_HEADER, + CodexGuardianRole, X_OPENAI_MEMGEN_REQUEST_HEADER, events::{self, retry_after_seconds_from_body}, sse::{SseEventDecoder, SseFrame}, }; @@ -30,7 +30,7 @@ use crate::transport::{ }, websocket::{ websocket_audit_artifact_from_attempt, websocket_connection_limit_failure, - websocket_payload_audit_snapshot, + websocket_payload_audit_snapshot, websocket_response_create_payload_text, }, }, response_meta, @@ -68,7 +68,6 @@ impl CodexBackendClient { if let Some(affinity) = &self.routing_affinity { affinity.apply(&endpoint, &mut headers); } - // OAuth 请求遵循 Codex 压缩合同;API Key 上游使用普通 JSON // Codex 上游只交付 SSE;即使下游请求 `stream: false`,也要上游流式执行, // 再由 API 层收集 canonical events 并返回完整 JSON // 不能把下游的传输偏好 @@ -76,7 +75,12 @@ impl CodexBackendClient { let mut upstream_body = upstream_request.body().clone(); upstream_body.insert("stream".to_owned(), serde_json::Value::Bool(true)); let mut upstream_body = serde_json::Value::Object(upstream_body); - if self.protocol == OpenAiUpstreamProtocol::Codex { + // Guardian 专用 HTTP 客户端使用默认 ResponsesOptions,普通 OAuth 及主审流使用 zstd + let compress = self.protocol == OpenAiUpstreamProtocol::Codex + && !upstream_request + .oauth_guardian_role(&self.middleware_headers) + .is_some_and(CodexGuardianRole::uses_sampler_transport); + if compress { headers.insert(CONTENT_ENCODING, HeaderValue::from_static("zstd")); } profile.apply_context_versions(&mut upstream_body); @@ -84,6 +88,9 @@ impl CodexBackendClient { &mut upstream_body, &mut headers, context.installation_id, + (self.protocol == OpenAiUpstreamProtocol::Codex) + .then_some(upstream_request.guardian_role) + .flatten(), ); self.apply_privacy(&mut upstream_body, &mut headers)?; let body = @@ -106,7 +113,7 @@ impl CodexBackendClient { Some(&headers), ); } - let body = if self.protocol == OpenAiUpstreamProtocol::Codex { + let body = if compress { zstd::stream::encode_all(std::io::Cursor::new(body), 3) .map_err(CodexClientError::RequestCompression)? } else { @@ -263,7 +270,8 @@ impl CodexBackendClient { }); } - let mut websocket_request = websocket_upstream_request(request); + let initial_start_ms = now_unix_timestamp_millis().to_string(); + let mut websocket_request = websocket_upstream_request(request, &initial_start_ms); let profile = self.profile.snapshot(); let mut headers = self.request_headers_for_websocket_response(&profile, &websocket_request, context)?; @@ -275,22 +283,16 @@ impl CodexBackendClient { } let mut body = serde_json::Value::Object(std::mem::take(websocket_request.body_mut())); profile.apply_context_versions(&mut body); - super::correlation::scope_request(&mut body, &mut headers, context.installation_id); + super::correlation::scope_request( + &mut body, + &mut headers, + context.installation_id, + (self.protocol == OpenAiUpstreamProtocol::Codex) + .then_some(request.guardian_role) + .flatten(), + ); let original_headers = self.privacy.as_ref().map(|_| headers.clone()); self.apply_privacy(&mut body, &mut headers)?; - if let Some(body) = body.as_object() { - super::diagnostics::evidence::record_request( - &context.trace.cloned().unwrap_or_default(), - if self.outbound_middleware.is_some() { - "provider.request.native" - } else { - "provider.request.outbound" - }, - body, - "websocket", - Some(&headers), - ); - } // 正文已归当前请求所有,移回对象避免再次复制完整对话 let serde_json::Value::Object(body) = body else { return Err(CodexClientError::Privacy( @@ -301,23 +303,36 @@ impl CodexBackendClient { )); }; *websocket_request.body_mut() = body; - let mut websocket_create = CodexWebSocketConnection::responses_create_request_for_path( + let trace = context.trace.cloned().unwrap_or_default(); + let record_body = |stage, request: &CodexResponsesRequest| { + super::diagnostics::evidence::record_request( + &trace, + stage, + request.body(), + "websocket", + Some(&headers), + ); + }; + if self.outbound_middleware.is_some() { + record_body("provider.request.native", &websocket_request); + } + let mut opening = CodexWebSocketConnection::response_create_opening_for_path( &self.base_url, self.protocol.responses_path(), &generate_key(), websocket_header_pairs(&headers), &websocket_request, - ) - .map_err(CodexClientError::WebSocketEncode)?; - websocket_create.connection.outbound_proxy = self.outbound_proxy.clone(); - websocket_create.connection.connection_budget = self.connection_budget.clone(); - let (websocket_create, outbound_profile) = - self.prepare_websocket_request(websocket_create).await?; + ); + opening.connection.outbound_proxy = self.outbound_proxy.clone(); + opening.connection.connection_budget = self.connection_budget.clone(); + let (plugin_payload, outbound_profile) = self + .prepare_websocket_request(&mut opening.connection, &websocket_request) + .await?; context.trace.cloned().unwrap_or_default().headers( "upstream.request.headers", serde_json::json!({"transport": "websocket", "phase": "prepared_opening"}), - websocket_create - .connection() + opening + .connection .headers() .iter() .map(|(name, value)| (name.as_str(), value.as_bytes())), @@ -327,7 +342,7 @@ impl CodexBackendClient { if websocket_audit_dir().is_some() { let artifact = websocket_audit_artifact_from_attempt( &websocket_request, - websocket_create.connection().opening_audit_snapshot(), + opening.connection.opening_audit_snapshot(), // 插件准备后只由受控 wire capture 记录实际正文,不把原生 JSON 冒充最终帧 self.outbound_middleware .is_none() @@ -349,8 +364,8 @@ impl CodexBackendClient { connection_profile.push_str(&profile); } // 上游按握手继承整条路径,不能把本轮请求交给其他路径建立的连接 - if let Some((_, route)) = websocket_create - .connection() + if let Some((_, route)) = opening + .connection .headers() .iter() .find(|(name, _)| name == gateway_protocol::peer::ROUTE_HEADER) @@ -395,8 +410,8 @@ impl CodexBackendClient { format!( "{}\0{}", websocket_origin_key( - &websocket_create - .connection() + &opening + .connection .endpoint() .replacen("wss://", "https://", 1) .replacen("ws://", "http://", 1) @@ -405,7 +420,7 @@ impl CodexBackendClient { ) }); let prepared = prepare_response_create_request_with_pool( - &websocket_create, + &opening, pool, &self.websocket_origin_breaker, opening_origin_key @@ -466,6 +481,31 @@ impl CodexBackendClient { } Err(error) => return Err(websocket_exchange_error_to_client_error(error)), }; + let payload = match plugin_payload { + Some(payload) => payload, + None => { + // 握手或租用完成后才标记发送时间。隐私规则移除或改写过的字段保持其最终值 + if let Some(stamp) = websocket_request + .body_mut() + .get_mut("client_metadata") + .and_then(|metadata| { + metadata.get_mut(X_CODEX_WS_STREAM_REQUEST_START_MS_CLIENT_METADATA_KEY) + }) + && stamp.as_str() == Some(initial_start_ms.as_str()) + { + *stamp = serde_json::Value::String(now_unix_timestamp_millis().to_string()); + } + record_body("provider.request.outbound", &websocket_request); + match websocket_response_create_payload_text(&websocket_request) { + Ok(payload) => payload, + Err(error) => { + prepared.discard().await; + return Err(CodexClientError::WebSocketEncode(error)); + } + } + } + }; + let websocket_create = opening.with_payload(payload); // 按最终出站帧的 UTF-8 字节数判断,握手上限只属于当前物理连接 if let Some(limit) = prepared.max_message_bytes() && websocket_create.payload_text().len() > limit @@ -655,6 +695,7 @@ impl CodexBackendClient { .with_egress_key(&self.egress_key) .with_outbound_proxy(self.outbound_proxy.as_ref()) .with_connection_profile(connection_profile) + .with_fedramp_routing(self.fedramp_routing) .with_installation_id(context.installation_id); key = key.with_routing_affinity(self.routing_affinity.as_ref().map(|pin| pin.id())); if let Some(connection_id) = request.downstream_websocket_connection_id.as_deref() { @@ -687,6 +728,7 @@ fn websocket_connection_profile( X_OPENAI_MEMGEN_REQUEST_HEADER, "x-codex-guardian", "x-openai-internal-codex-residency", + "x-openai-fedramp", "x-openai-account-routing-override", ] .map(|name| { diff --git a/backend/crates/providers/openai/src/transport/correlation.rs b/backend/crates/providers/openai/src/transport/correlation.rs index c6e21db41..18b132194 100644 --- a/backend/crates/providers/openai/src/transport/correlation.rs +++ b/backend/crates/providers/openai/src/transport/correlation.rs @@ -1,5 +1,6 @@ //! 在出站副本中隔离账号的追踪标识,不改变本地亲和、续接引用或业务正文 +use gateway_protocol::openai::CodexGuardianRole; use reqwest::header::{HeaderMap, HeaderValue}; use serde_json::{Map, Value}; use sha2::{Digest, Sha256}; @@ -14,6 +15,7 @@ const ID_FIELDS: &[&str] = &[ "window_id", "context_window_id", "parent_thread_id", + "guardian_classifier_source_thread_id", "forked_from_thread_id", "conversation_id", "x-codex-window-id", @@ -177,10 +179,33 @@ pub(super) fn scope_headers(headers: &mut HeaderMap, installation_id: Option<&st } } +fn guardian_cache_key( + metadata: &Value, + role: CodexGuardianRole, + cache: &str, + installation_id: &str, +) -> Option { + let (prefix, original) = cache.split_once(':')?; + uuid::Uuid::parse_str(original).ok()?; + let source = match (role, prefix) { + (CodexGuardianRole::Reviewer, "guardian") => { + metadata.get("x-codex-parent-thread-id")?.as_str()? == original + } + (CodexGuardianRole::Classifier, "guardian-v2") => { + let turn: Value = + serde_json::from_str(metadata.get("x-codex-turn-metadata")?.as_str()?).ok()?; + turn.get("guardian_classifier_source_thread_id")?.as_str()? == original + } + _ => return None, + }; + source.then(|| format!("{prefix}:{}", scoped_id(installation_id, original))) +} + pub(super) fn scope_request( body: &mut Value, headers: &mut HeaderMap, installation_id: Option<&str>, + guardian: Option, ) { scope_headers(headers, installation_id); let Some(installation_id) = installation_id else { @@ -188,7 +213,19 @@ pub(super) fn scope_request( }; if let Some(object) = body.as_object_mut() { map_fields(object, installation_id, ID_FIELDS); - map_fields(object, installation_id, &["prompt_cache_key"]); + // 官方 Guardian 的复合缓存键引用父线程;自定义键仍作为一个整体隔离 + if let Some(cache) = object + .get("prompt_cache_key") + .and_then(Value::as_str) + .filter(|v| !v.is_empty()) + { + let mapped = guardian + .and_then(|role| { + guardian_cache_key(object.get("client_metadata")?, role, cache, installation_id) + }) + .unwrap_or_else(|| scoped_id(installation_id, cache)); + object.insert("prompt_cache_key".into(), Value::from(mapped)); + } for key in METADATA_FIELDS { if let Some(value) = object.get_mut(*key) { scope_metadata(value, installation_id); diff --git a/backend/crates/providers/openai/src/transport/headers.rs b/backend/crates/providers/openai/src/transport/headers.rs index 157476a22..2ba32add0 100644 --- a/backend/crates/providers/openai/src/transport/headers.rs +++ b/backend/crates/providers/openai/src/transport/headers.rs @@ -137,6 +137,9 @@ impl CodexBackendClient { } }; let mut headers = build_codex_model_headers(profile, context.authorization, account_id)?; + if self.fedramp_routing { + headers.insert("x-openai-fedramp", HeaderValue::from_static("true")); + } insert_optional_header(&mut headers, "cookie", cookie_header)?; Ok(headers) } @@ -161,6 +164,7 @@ impl CodexBackendClient { context: CodexRequestContext<'_>, ) -> CodexClientResult { let mut headers = self.response_headers(profile, request, context)?; + self.append_middleware_headers(&mut headers)?; headers.insert(ACCEPT, HeaderValue::from_static("text/event-stream")); headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json")); insert_optional_protocol_header( @@ -178,6 +182,9 @@ impl CodexBackendClient { context: CodexRequestContext<'_>, ) -> CodexClientResult { let mut headers = self.response_headers(profile, request, context)?; + // WebSocket 逐帧回传轮次状态,握手不能把某一轮的 token 绑定到整条连接 + headers.remove("x-codex-turn-state"); + self.append_middleware_headers(&mut headers)?; headers.insert( HeaderName::from_static("openai-beta"), HeaderValue::from_static("responses_websockets=2026-02-06"), @@ -222,13 +229,23 @@ impl CodexBackendClient { if let Some(subagent) = openai_subagent_from_metadata(request.client_metadata()) { insert_optional_protocol_header(&mut headers, "x-openai-subagent", Some(&subagent)); } - let routing_hint = match request.service_tier() { - Some(tier) => format!("model={};tier={tier}", request.model()), - None => format!("model={}", request.model()), - }; - insert_optional_protocol_header(&mut headers, "x-codex-routing-hint", Some(&routing_hint)); + let guardian = (self.protocol == OpenAiUpstreamProtocol::Codex) + .then(|| request.oauth_guardian_role(&self.middleware_headers)) + .flatten(); + if let Some(role) = guardian { + insert_optional_protocol_header(&mut headers, "x-codex-guardian", role.header()); + } else { + let routing_hint = match request.service_tier() { + Some(tier) => format!("model={};tier={tier}", request.model()), + None => format!("model={}", request.model()), + }; + insert_optional_protocol_header( + &mut headers, + "x-codex-routing-hint", + Some(&routing_hint), + ); + } append_passthrough_headers(&mut headers, &request.passthrough_headers); - self.append_middleware_headers(&mut headers)?; Ok(headers) } @@ -252,7 +269,8 @@ impl CodexBackendClient { pub(super) fn append_passthrough_headers(headers: &mut HeaderMap, passthrough: &HeaderMap) { for name in passthrough.keys() { // 身份与传输字段只由画像/正文生成;其余协议头保留原始多值字节 - if is_managed_identity_header(name.as_str()) + if (name == "x-openai-fedramp" && headers.contains_key(name)) + || is_managed_identity_header(name.as_str()) || matches!( name.as_str(), "openai-beta" diff --git a/backend/crates/providers/openai/src/transport/outbound.rs b/backend/crates/providers/openai/src/transport/outbound.rs index 650ea272b..4ebe41c81 100644 --- a/backend/crates/providers/openai/src/transport/outbound.rs +++ b/backend/crates/providers/openai/src/transport/outbound.rs @@ -17,7 +17,10 @@ use tungstenite::http; use super::{ client::{CodexBackendClient, CodexClientError, CodexClientResult}, - websocket::CodexWebSocketRequest, + protocol::{ + responses::CodexResponsesRequest, websocket::websocket_response_create_payload_text, + }, + websocket::CodexWebSocketConnection, }; impl CodexBackendClient { @@ -104,13 +107,13 @@ impl CodexBackendClient { pub(super) async fn prepare_websocket_request( &self, - mut request: CodexWebSocketRequest, - ) -> CodexClientResult<(CodexWebSocketRequest, Option)> { + connection: &mut CodexWebSocketConnection, + frame: &CodexResponsesRequest, + ) -> CodexClientResult<(Option, Option)> { let path = if self.peer_route.is_some() && self.protocol != super::client::OpenAiUpstreamProtocol::Codex { - let target = - Url::parse(request.connection().endpoint()).map_err(|_| invalid_request())?; + let target = Url::parse(connection.endpoint()).map_err(|_| invalid_request())?; self.route_to(&target) .map(http::HeaderValue::to_str) .transpose() @@ -118,33 +121,34 @@ impl CodexBackendClient { } else { None }; - request.connection.set_peer_route(path); - self.prepare_websocket_outbound(request).await + connection.set_peer_route(path); + self.prepare_websocket_outbound(connection, frame).await } async fn prepare_websocket_outbound( &self, - mut request: CodexWebSocketRequest, - ) -> CodexClientResult<(CodexWebSocketRequest, Option)> { + connection: &mut CodexWebSocketConnection, + frame: &CodexResponsesRequest, + ) -> CodexClientResult<(Option, Option)> { let Some(pipeline) = &self.outbound_middleware else { - return Ok((request, None)); + return Ok((None, None)); }; - let uri: http::Uri = request - .connection() + let uri: http::Uri = connection .endpoint() .parse() .map_err(|_| invalid_request())?; let outbound = Request { target: Target::WebSocket { uri: uri.clone() }, - headers: request - .connection() + headers: connection .headers() .iter() .map(|(name, value)| { MiddlewareHeader::new(name.clone(), Bytes::copy_from_slice(value.as_bytes())) }) .collect(), - body: request.take_payload_text().into(), + body: websocket_response_create_payload_text(frame) + .map_err(CodexClientError::WebSocketEncode)? + .into(), }; let original_headers = outbound .header_map() @@ -180,12 +184,11 @@ impl CodexBackendClient { .collect::>>()?; let payload = String::from_utf8(prepared.body.into()).map_err(|_| invalid_request())?; // 只替换候选 opening 和正文;原请求的 continuation 归属不从插件正文重建 - request.replace_outbound(endpoint, headers, payload); - request - .connection + connection.replace_outbound(endpoint, headers); + connection .validate_prepared_opening() .map_err(|_| invalid_request())?; - Ok((request, profile)) + Ok((Some(payload), profile)) } } diff --git a/backend/crates/providers/openai/src/transport/protocol/responses.rs b/backend/crates/providers/openai/src/transport/protocol/responses.rs index c2a9b6415..7b3b7705a 100644 --- a/backend/crates/providers/openai/src/transport/protocol/responses.rs +++ b/backend/crates/providers/openai/src/transport/protocol/responses.rs @@ -3,7 +3,9 @@ use std::{fmt, time::Duration}; use gateway_core::account::FastMode; +use gateway_core::engine::middleware::MiddlewareHeader; use gateway_protocol::openai::{ + CODEX_AUTO_REVIEW_MODEL, CodexGuardianRole, CodexResponsesRequestSemantics as CodexRequestSemantics, codex_responses_request_semantics_with_turn_metadata, events, }; @@ -59,6 +61,8 @@ pub struct CodexResponsesRequest { body: Map, /// API 边界保存、Provider 逐条恢复的普通客户端请求头 pub(crate) passthrough_headers: HeaderMap, + /// 原始请求的 Guardian 身份,保留 HTTP 两侧冲突和 WS 帧边界的判定结果 + pub(crate) guardian_role: Option, /// 是否由客户端显式提供了 prompt cache key pub explicit_prompt_cache_key: bool, /// 客户端会话 ID @@ -617,6 +621,7 @@ impl CodexResponsesRequest { Self { body, passthrough_headers: HeaderMap::new(), + guardian_role: None, explicit_prompt_cache_key: false, client_conversation_id: None, client_session_id: None, @@ -801,6 +806,30 @@ impl CodexResponsesRequest { self.subagent_kind().as_deref() == Some(GUARDIAN_SUBAGENT_KIND) } + /// Codex 仅为实际选中的专用审核模型补 reviewer 标记,显式头及中间件仍有各自的覆盖权 + pub(crate) fn oauth_guardian_role( + &self, + middleware_headers: &[MiddlewareHeader], + ) -> Option { + const HEADER: &str = "x-codex-guardian"; + let header = middleware_headers + .iter() + .find(|header| header.name().eq_ignore_ascii_case(HEADER)) + .map(|header| header.value().as_ref()) + .or_else(|| self.passthrough_headers.get(HEADER).map(|v| v.as_bytes())); + match header { + Some(b"reviewer") => Some(CodexGuardianRole::Reviewer), + Some(b"classifier") => Some(CodexGuardianRole::Classifier), + Some(_) => None, + None if self.guardian_role == Some(CodexGuardianRole::Reviewer) + && self.model() != CODEX_AUTO_REVIEW_MODEL => + { + None + } + None => self.guardian_role, + } + } + /// 设置 / 合并 client metadata pub fn set_client_metadata(&mut self, client_metadata: Option) { match client_metadata { diff --git a/backend/crates/providers/openai/src/transport/request.rs b/backend/crates/providers/openai/src/transport/request.rs index 6b02945ee..049a96aff 100644 --- a/backend/crates/providers/openai/src/transport/request.rs +++ b/backend/crates/providers/openai/src/transport/request.rs @@ -3,7 +3,7 @@ use std::io; use base64::{Engine as _, engine::general_purpose::STANDARD}; -use gateway_core::operation::GenerateRequest; +use gateway_core::{account::OpenAiRequestCountry, operation::GenerateRequest}; use gateway_protocol::openai::{ OPENAI_PROTOCOL, WS_REQUEST_HEADER_RESPONSES_LITE_CLIENT_METADATA_KEY, is_transport_managed_request_header, @@ -106,14 +106,28 @@ pub fn encode_generate_request( request: &GenerateRequest, upstream_model: &str, location: Option<&CodexRequestLocation>, +) -> Result { + let mut encoded = encode_generate_payload(request, upstream_model)?; + align_structured_location_fields( + encoded.body_mut(), + location, + &OpenAiRequestCountry::default(), + ); + Ok(encoded) +} + +// 选号前保留下游国家字段的缺省、null 与显式值,位置和国家策略在原生出站时统一应用 +pub(crate) fn encode_generate_payload( + request: &GenerateRequest, + upstream_model: &str, ) -> Result { let payload = request.protocol_payload(); if payload.protocol() != OPENAI_PROTOCOL { return Err(CodexRequestEncodeError::InvalidProtocolPayload); } let mut body = payload.body().clone(); - adapt_codex_responses_body(&mut body, upstream_model, location); - + body.insert("model".to_owned(), Value::String(upstream_model.to_owned())); + normalize_codex_request_body(&mut body); let mut encoded = CodexResponsesRequest::from_body(body); encoded.explicit_prompt_cache_key = encoded.prompt_cache_key().is_some(); extract_request_context(&mut encoded); @@ -121,23 +135,26 @@ pub fn encode_generate_request( Ok(encoded) } -fn adapt_codex_responses_body( - body: &mut Map, - upstream_model: &str, - location: Option<&CodexRequestLocation>, -) { - body.insert("model".to_owned(), Value::String(upstream_model.to_owned())); - normalize_codex_request_body(body); - align_structured_location_fields(body, location); -} - pub(crate) fn align_structured_location_fields( body: &mut Map, location: Option<&CodexRequestLocation>, + country: &OpenAiRequestCountry, ) { - // 请求国家由生效的位置覆盖决定,未配置时显式发送 null 表示未知 - let country = location.map(|location| location.country.as_str()); - body.insert("request_country".to_owned(), Value::from(country)); + match country { + OpenAiRequestCountry::Default {} => { + body.insert("request_country".into(), Value::Null); + } + OpenAiRequestCountry::Passthrough {} => {} + OpenAiRequestCountry::FollowLocation {} => { + body.insert( + "request_country".into(), + Value::from(location.map(|location| location.country.as_str())), + ); + } + OpenAiRequestCountry::Custom { country } => { + body.insert("request_country".into(), Value::from(country.as_str())); + } + } let Some(location) = location else { return }; if let Some(input) = body.get_mut("input").and_then(Value::as_array_mut) { for item in input { @@ -731,6 +748,7 @@ fn replace_metadata_field(metadata: &mut Map, key: &str, value: O // 优先;body 顶层别名只在 header 缺失时兜底(例如 WebSocket 帧无法逐轮携带 // 请求头的场景) fn apply_protocol_context(request: &mut CodexResponsesRequest, context: &Map) { + request.guardian_role = gateway_protocol::openai::codex_guardian_role(request.body(), context); request.passthrough_headers = decode_passthrough_headers(context); request.websocket_frame = context .get(gateway_protocol::openai::WEBSOCKET_FRAME_CONTEXT_KEY) diff --git a/backend/crates/providers/openai/src/transport/websocket/coordinator.rs b/backend/crates/providers/openai/src/transport/websocket/coordinator.rs index 03ca71d92..3146370c8 100644 --- a/backend/crates/providers/openai/src/transport/websocket/coordinator.rs +++ b/backend/crates/providers/openai/src/transport/websocket/coordinator.rs @@ -21,7 +21,7 @@ use super::{ handshake::{connect_pumped_websocket, send_websocket_request, websocket_connection_metadata}, model::{ CodexWebSocketConnection, CodexWebSocketRequest, PreviousResponseUnavailableReason, - WebSocketContinuationRequirement, + ResponseCreateOpening, WebSocketContinuationRequirement, }, pool::{ self, CodexWebSocketPool, CodexWebSocketPoolKey, PooledWebSocketConnection, @@ -121,7 +121,7 @@ impl PreparedWebSocket { /// 只建立或租用 WebSocket,不发送 payload pub(crate) async fn prepare_response_create_request_with_pool( - request: &CodexWebSocketRequest, + request: &ResponseCreateOpening, pool: Option<( &CodexWebSocketPool, Option, @@ -135,7 +135,7 @@ pub(crate) async fn prepare_response_create_request_with_pool( ) -> Result, CodexWebSocketExchangeError> { let decision_started_at = Instant::now(); let Some((pool, Some(key), downstream_cancellation)) = pool else { - if require_pool || !request.continuation().permits_fresh_connection() { + if require_pool || !request.continuation.permits_fresh_connection() { return Err(continuation_unavailable( PreviousResponseUnavailableReason::PoolUnavailable, )); @@ -152,7 +152,7 @@ pub(crate) async fn prepare_response_create_request_with_pool( .await; }; - let required_response_id = match request.continuation() { + let required_response_id = match &request.continuation { WebSocketContinuationRequirement::ConnectionLocal { response_id } => { Some(response_id.as_str()) } @@ -165,14 +165,14 @@ pub(crate) async fn prepare_response_create_request_with_pool( &key, required_response_id, request.codex_search_declared == Some(true), - request.connection().outbound_proxy.as_ref(), + request.connection.outbound_proxy.as_ref(), downstream_cancellation, ) .await { WebSocketPoolAcquire::Reused { connection, lease } => { if let WebSocketContinuationRequirement::ConnectionLocal { response_id } = - request.continuation() + &request.continuation && connection.continuation.latest_response_id() != Some(response_id.as_str()) { lease.put(*connection).await; @@ -193,7 +193,7 @@ pub(crate) async fn prepare_response_create_request_with_pool( })) } WebSocketPoolAcquire::Connect(connect_lease) => { - if !request.continuation().permits_fresh_connection() { + if !request.continuation.permits_fresh_connection() { connect_lease.failed().await; return Err(continuation_unavailable( PreviousResponseUnavailableReason::FreshConnectionRequired, @@ -211,7 +211,7 @@ pub(crate) async fn prepare_response_create_request_with_pool( .await } WebSocketPoolAcquire::Wait(waiter) => { - if require_pool || !request.continuation().permits_fresh_connection() { + if require_pool || !request.continuation.permits_fresh_connection() { return Err(continuation_unavailable( PreviousResponseUnavailableReason::ConnectionBusy, )); @@ -235,7 +235,7 @@ pub(crate) async fn prepare_response_create_request_with_pool( } async fn prepare_unpooled_websocket( - request: &CodexWebSocketRequest, + request: &ResponseCreateOpening, breaker: &WebSocketOriginBreaker, origin_key: &str, fast_path_budget: Option, @@ -244,20 +244,15 @@ async fn prepare_unpooled_websocket( capacity_pool: Option<&CodexWebSocketPool>, ) -> Result, CodexWebSocketExchangeError> { let proxy_permit = if let Some(pool) = capacity_pool { - pool.acquire_proxy_capacity(request.connection().outbound_proxy.as_ref(), None) + pool.acquire_proxy_capacity(request.connection.outbound_proxy.as_ref(), None) .await? } else { None }; let permit = acquire_breaker_permit(breaker, origin_key, fast_path_budget.is_some())?; - let context = pump_log_context_from_connection(request.connection()); - let connected = connect_with_budget( - request.connection(), - fast_path_budget, - context, - proxy_permit, - ) - .await; + let context = pump_log_context_from_connection(&request.connection); + let connected = + connect_with_budget(&request.connection, fast_path_budget, context, proxy_permit).await; let connected = match connected { Ok(WebSocketFastPath::Ready(connection)) => Ok(connection), Ok(WebSocketFastPath::Missed) => { @@ -279,7 +274,7 @@ async fn prepare_unpooled_websocket( } async fn prepare_pooled_websocket( - request: &CodexWebSocketRequest, + request: &ResponseCreateOpening, pool: &CodexWebSocketPool, connect_lease: WebSocketPoolConnectLease, breaker: &WebSocketOriginBreaker, @@ -295,7 +290,7 @@ async fn prepare_pooled_websocket( } }; let mut waiter = start_pooled_websocket_connect( - request.connection().clone(), + request.connection.clone(), pool.clone(), connect_lease, permit, @@ -674,7 +669,7 @@ pub(crate) async fn execute_prepared_response_create_request_stream( created_at, continuation, initial_search_declared: initial_search_declared - .unwrap_or(request.codex_search_declared.unwrap_or(false)), + .unwrap_or(request.opening.codex_search_declared.unwrap_or(false)), }); let mut exchange = stream_websocket_response( websocket, diff --git a/backend/crates/providers/openai/src/transport/websocket/handshake.rs b/backend/crates/providers/openai/src/transport/websocket/handshake.rs index 731873497..7ad68a040 100644 --- a/backend/crates/providers/openai/src/transport/websocket/handshake.rs +++ b/backend/crates/providers/openai/src/transport/websocket/handshake.rs @@ -27,7 +27,10 @@ use crate::{ use super::{ error::CodexWebSocketExchangeError, - model::{CodexWebSocketConnection, CodexWebSocketRequest, WebSocketContinuationRequirement}, + model::{ + CodexWebSocketConnection, CodexWebSocketRequest, ResponseCreateOpening, + WebSocketContinuationRequirement, + }, pool::CodexWebSocketConnectionMetadata, pump::{PumpLogContext, PumpedWebSocket, RawWsStream}, }; @@ -102,34 +105,34 @@ impl CodexWebSocketConnection { business_headers: Vec<(String, String)>, request: &CodexResponsesRequest, ) -> Result { - Self::responses_create_request_for_path( + Ok(Self::response_create_opening_for_path( base_url, CODEX_RESPONSES_PATH, websocket_key, business_headers, request, ) + .with_payload(websocket_response_create_payload_text(request)?)) } - pub(crate) fn responses_create_request_for_path( + pub(crate) fn response_create_opening_for_path( base_url: &str, path: &str, websocket_key: &str, business_headers: Vec<(String, String)>, request: &CodexResponsesRequest, - ) -> Result { + ) -> ResponseCreateOpening { let mut connection = Self::responses(base_url, websocket_key, business_headers); let endpoint = crate::transport::endpoint_url(base_url, path); connection.endpoint = endpoint .replacen("https://", "wss://", 1) .replacen("http://", "ws://", 1); - Ok(CodexWebSocketRequest { + ResponseCreateOpening { connection, - payload_text: websocket_response_create_payload_text(request)?, continuation: WebSocketContinuationRequirement::from_request(request), codex_search_declared: (path == CODEX_RESPONSES_PATH) .then(|| crate::compat::declares_hosted_search(request.body())), - }) + } } } diff --git a/backend/crates/providers/openai/src/transport/websocket/model.rs b/backend/crates/providers/openai/src/transport/websocket/model.rs index 02a092bef..ea163c828 100644 --- a/backend/crates/providers/openai/src/transport/websocket/model.rs +++ b/backend/crates/providers/openai/src/transport/websocket/model.rs @@ -48,8 +48,14 @@ impl Eq for CodexWebSocketConnection {} /// 已构造完成的 Responses WebSocket 请求描述 #[derive(Debug, Clone, PartialEq, Eq)] pub struct CodexWebSocketRequest { - pub(crate) connection: CodexWebSocketConnection, + pub(crate) opening: ResponseCreateOpening, pub(super) payload_text: String, +} + +/// 建连与选择连接只读取路由和续接要求,原生推理帧在连接就绪后编码 +#[derive(Debug, Clone, PartialEq, Eq)] +pub(crate) struct ResponseCreateOpening { + pub(crate) connection: CodexWebSocketConnection, pub(super) continuation: WebSocketContinuationRequirement, // 仅 Codex backend 约束首包搜索初始化,API Key 的 Responses API 不采用此规则 pub(super) codex_search_declared: Option, @@ -127,24 +133,9 @@ impl fmt::Display for PreviousResponseUnavailableReason { } impl CodexWebSocketRequest { - pub(crate) fn take_payload_text(&mut self) -> String { - std::mem::take(&mut self.payload_text) - } - - pub(crate) fn replace_outbound( - &mut self, - endpoint: String, - headers: Vec<(String, String)>, - payload: String, - ) { - self.connection.endpoint = endpoint; - self.connection.headers = headers; - self.payload_text = payload; - } - /// 返回连接描述 pub fn connection(&self) -> &CodexWebSocketConnection { - &self.connection + &self.opening.connection } /// 返回将要发送的完整 `response.create` 文本 @@ -154,11 +145,25 @@ impl CodexWebSocketRequest { /// 返回连接续接要求 pub fn continuation(&self) -> &WebSocketContinuationRequirement { - &self.continuation + &self.opening.continuation + } +} + +impl ResponseCreateOpening { + pub(crate) fn with_payload(self, payload_text: String) -> CodexWebSocketRequest { + CodexWebSocketRequest { + opening: self, + payload_text, + } } } impl CodexWebSocketConnection { + pub(crate) fn replace_outbound(&mut self, endpoint: String, headers: Vec<(String, String)>) { + self.endpoint = endpoint; + self.headers = headers; + } + pub(crate) fn set_peer_route(&mut self, path: Option<&str>) { self.headers .retain(|(name, _)| !name.eq_ignore_ascii_case(gateway_protocol::peer::ROUTE_HEADER)); diff --git a/backend/crates/providers/openai/src/transport/websocket/pool/state.rs b/backend/crates/providers/openai/src/transport/websocket/pool/state.rs index 1f8880473..a2d4be6b0 100644 --- a/backend/crates/providers/openai/src/transport/websocket/pool/state.rs +++ b/backend/crates/providers/openai/src/transport/websocket/pool/state.rs @@ -26,6 +26,7 @@ pub struct CodexWebSocketPoolKey { connection_profile: String, installation_id: Option, routing_affinity_id: Option, + fedramp_routing: bool, pub(super) downstream_connection_id: String, egress_key: String, pub(super) proxy_capacity_key: String, @@ -45,6 +46,7 @@ impl CodexWebSocketPoolKey { connection_profile: String::new(), installation_id: None, routing_affinity_id: None, + fedramp_routing: false, downstream_connection_id: String::new(), egress_key: String::new(), proxy_capacity_key: String::new(), @@ -81,6 +83,12 @@ impl CodexWebSocketPoolKey { self } + /// 凭据声明的 FedRAMP 路由也是精确续接的边界,不能把旧响应交给另一条路由 + pub(crate) fn with_fedramp_routing(mut self, enabled: bool) -> Self { + self.fedramp_routing = enabled; + self + } + pub(crate) fn with_egress_key(mut self, key: &str) -> Self { self.egress_key = key.to_owned(); self @@ -108,6 +116,7 @@ impl CodexWebSocketPoolKey { self.account_id.as_str(), self.conversation_id.as_str(), self.connection_profile.as_str(), + if self.fedramp_routing { "fedramp" } else { "" }, self.installation_id.as_deref().unwrap_or_default(), self.downstream_connection_id.as_str(), self.egress_key.as_str(), @@ -122,6 +131,7 @@ impl CodexWebSocketPoolKey { && self.conversation_id == other.conversation_id && self.egress_key == other.egress_key && self.routing_affinity_id == other.routing_affinity_id + && self.fedramp_routing == other.fedramp_routing } } diff --git a/backend/crates/providers/openai/tests/compat/headers.rs b/backend/crates/providers/openai/tests/compat/headers.rs index 0e2466f56..7a7ec1269 100644 --- a/backend/crates/providers/openai/tests/compat/headers.rs +++ b/backend/crates/providers/openai/tests/compat/headers.rs @@ -486,5 +486,5 @@ async fn backend_websocket_should_preserve_business_headers_without_downstream_t assert!(values("x-codex-installation-id").is_empty()); let session = values("session-id"); assert!(uuid::Uuid::parse_str(std::str::from_utf8(&session[0]).unwrap()).is_ok()); - assert_eq!(values("x-codex-turn-state"), vec![b"turn-ascii".to_vec()]); + assert!(values("x-codex-turn-state").is_empty()); } diff --git a/backend/crates/providers/openai/tests/provider/contract/account_isolation.rs b/backend/crates/providers/openai/tests/provider/contract/account_isolation.rs index 478c000af..932aced05 100644 --- a/backend/crates/providers/openai/tests/provider/contract/account_isolation.rs +++ b/backend/crates/providers/openai/tests/provider/contract/account_isolation.rs @@ -190,6 +190,171 @@ fn assert_isolated_request( assert_eq!(body["input"], isolation_history()); } +fn fedramp_secret(access_token: &str) -> provider_openai::credential::CodexOAuthSecret { + let mut credential = secret(access_token); + let claims = base64::engine::general_purpose::URL_SAFE_NO_PAD + .encode(br#"{"https://api.openai.com/auth":{"chatgpt_account_is_fedramp":true}}"#); + credential.id_token = Some(format!("header.{claims}.signature").into()); + credential +} + +#[tokio::test] +async fn rotated_fedramp_claim_opens_a_new_socket_for_the_same_account_and_session() { + let store = Arc::new(MemoryAccountStore::default()); + create_account(&store, SELECTED_ACCOUNT).await; + let server = RoutingUpstream::start(Some(Vec::new())).await; + let provider = provider_with_base_url(&store, server.url.clone()); + let mut session = ProviderSessionState::new( + "openai", + Map::from_iter([ + ("account_id".into(), json!(SELECTED_ACCOUNT)), + ("conversation_id".into(), json!("fedramp-session")), + ("continuation_scope".into(), json!("connection_local")), + ]), + ) + .unwrap(); + for (id, exact) in [ + ("resp_fedramp_seed", false), + ("resp_fedramp_reuse", false), + ("resp_old_handle", true), + ("resp_fedramp_rotated", false), + ] { + if exact { + let account = store + .get_account(&ProviderAccountId::new(SELECTED_ACCOUNT).unwrap()) + .await + .unwrap() + .unwrap(); + let rotated = fedramp_secret(&format!("at-{SELECTED_ACCOUNT}")); + store + .repository() + .rotate_refreshed_oauth_secret(&account, rotated, None, None) + .await + .unwrap(); + } + let mut body = Map::from_iter([ + ("model".into(), json!("gpt-5.4")), + ("input".into(), json!([])), + ("store".into(), json!(false)), + ("client_metadata".into(), json!({"fixture_response_id": id})), + ]); + let context = if exact { + body.insert("previous_response_id".into(), json!("resp_fedramp_reuse")); + pinned_continuation_context( + "req_fedramp_exact", + SELECTED_ACCOUNT, + "resp_fedramp_reuse", + "resp_fedramp_reuse", + 1, + ContinuationAttempt::Native, + ) + } else { + isolation_context(None) + }; + let payload = ProtocolPayload::json_object("openai", body) + .unwrap() + .with_context(Map::from_iter([ + ("use_websocket".into(), json!(true)), + ( + "downstream_websocket_connection_id".into(), + json!("fedramp-connection"), + ), + ])); + let operation = Operation::Generate( + GenerateRequest::from_protocol_payload(payload) + .with_provider_session_state(session.clone()), + ); + let mut stream = Arc::clone(&provider) + .execute(planned_request("openai", operation), context) + .await + .unwrap(); + if exact { + let error = loop { + match stream.next().await { + Some(Ok(event)) => assert!(!event.has_client_event()), + Some(Err(error)) => break error, + None => panic!("old route must reject the exact continuation before sending"), + } + }; + assert_eq!( + error.continuation_recovery_disposition(), + Some(ContinuationRecoveryDisposition::ClientReplayRequired) + ); + assert_eq!(error.send_state(), UpstreamSendState::NotSent); + assert_eq!( + error.continuation_unavailable_reason(), + Some("fresh_connection_required") + ); + } else { + while let Some(event) = stream.next().await { + let event = event.unwrap(); + if let Some(update) = event.session_update() { + session = update.clone(); + } + } + } + } + let captured = server.requests.lock().unwrap(); + let [seed, reuse, fresh] = captured.as_slice() else { + panic!("only the three compatible frames should be sent") + }; + assert_eq!(seed.0, reuse.0); + assert_ne!(reuse.0, fresh.0); + assert!(!seed.1.contains_key("x-openai-fedramp")); + assert_eq!(fresh.1["x-openai-fedramp"], "true"); +} + +#[tokio::test] +async fn selected_oauth_fedramp_claim_sets_a_single_header_even_after_account_switch() { + let store = Arc::new(MemoryAccountStore::default()); + store + .seed_oauth_credential(ImportCodexOAuthCredential { + account_id: SELECTED_ACCOUNT.to_owned(), + name: SELECTED_ACCOUNT.to_owned(), + secret: fedramp_secret("at-fedramp"), + verified_account: profile("chatgpt-fedramp"), + next_refresh_at: None, + enabled: true, + }) + .await; + let server = MockServer::start().await; + Mock::given(method("POST")) + .and(path("/codex/responses")) + .respond_with( + ResponseTemplate::new(200) + .insert_header("content-type", "text/event-stream") + .set_body_string(CAPTURE_COMPLETED_SSE), + ) + .expect(2) + .mount(&server) + .await; + let provider = provider_with_base_url(&store, server.uri()); + for owner in [SELECTED_ACCOUNT, "acct_scope_old"] { + let payload = isolation_payload(); + let mut metadata = payload.context().clone(); + metadata.insert("use_websocket".into(), json!(false)); + let operation = Operation::Generate(GenerateRequest::from_protocol_payload( + payload.with_context(metadata), + )); + let mut stream = provider + .clone() + .execute( + planned_request("openai", operation), + isolation_context(Some(owner)), + ) + .await + .unwrap(); + while let Some(event) = stream.next().await { + event.unwrap(); + } + } + for request in server.received_requests().await.unwrap() { + let values: Vec<_> = request.headers.get_all("x-openai-fedramp").iter().collect(); + assert_eq!(values.len(), 1); + assert_eq!(values[0], "true"); + } +} + #[tokio::test] async fn http_scopes_client_headers_and_guardian_parent_reference_to_the_account() { for owner in [Some(SELECTED_ACCOUNT), Some("acct_scope_old"), None] { @@ -515,8 +680,25 @@ async fn guardian_pins_follow_parent_connection_and_separate_reviewer_pool_reuse ) .await; } + let payload = ProtocolPayload::json_object("openai", json!({ + "model":"gpt-5.4","input":"hello","client_metadata":{ + "fixture_response_id":"classifier","parent_response_id":"parent_a","x-openai-subagent":"guardian", + "x-codex-turn-metadata":r#"{"thread_source":"guardian_classifier","turn_trigger":"guardian_classifier"}"#} + }).as_object().unwrap().clone()).unwrap().with_context(Map::from_iter([("use_websocket".to_owned(),json!(true))])); + execute_routing( + &provider, + Operation::Generate(GenerateRequest::from_protocol_payload(payload)), + routing_context("classifier", "key_routing", SELECTED_ACCOUNT), + ) + .await; let requests = server.requests.lock().unwrap(); - assert_eq!(requests.len(), 5); + assert_eq!(requests.len(), 6); + assert_eq!(requests[5].1["x-codex-guardian"], "classifier"); + assert_eq!( + requests[5].2["client_metadata"]["parent_response_id"], + "parent_a" + ); + assert!(!requests[5].1.contains_key("cookie")); assert_eq!( requests[2].0, requests[3].0, "same parent keeps the reviewer socket" @@ -536,6 +718,107 @@ async fn guardian_pins_follow_parent_connection_and_separate_reviewer_pool_reuse ); } +#[tokio::test] +async fn guardian_structured_roles_use_selected_model_and_observed_http_parent_without_cookies() { + let store = Arc::new(MemoryAccountStore::default()); + create_account(&store, "acct_provider_contract").await; + let server = MockServer::start().await; + Mock::given(method("POST")) + .and(path("/codex/responses")) + .respond_with( + ResponseTemplate::new(200).set_body_raw( + format!("data: {}\n\n{}", json!({"type":"response.created","response":{"id":"resp_scope_capture","model":"gpt-5.4"}}), CAPTURE_COMPLETED_SSE), + "text/event-stream", + ), + ) + .expect(5) + .mount(&server) + .await; + let provider = provider_with_base_url(&store, server.uri()); + for (id, model, role, parent) in [ + ("root", "gpt-5.4", None, None), + ( + "review", + "codex-auto-review", + Some("guardian_review"), + Some("resp_scope_capture"), + ), + ( + "unobserved", + "codex-auto-review", + Some("guardian_review"), + Some("unknown"), + ), + ( + "classifier", + "gpt-5.4", + Some("guardian_classifier"), + Some("resp_scope_capture"), + ), + ("custom", "gpt-5.4", Some("guardian_review"), None), + ] { + let mut body = json!({"model":"gpt-5.6-luna","input":[]}); + if let Some(role) = role { + body["client_metadata"] = json!({ + "x-openai-subagent":"guardian", + "x-codex-turn-metadata": json!({"thread_source":role}).to_string(), + "guardian_credits_requested":"true" + }); + } + if let Some(parent) = parent { + body["client_metadata"]["parent_response_id"] = json!(parent); + } + let payload = ProtocolPayload::json_object("openai", body.as_object().unwrap().clone()) + .unwrap() + .with_context(Map::from_iter([("use_websocket".to_owned(), json!(false))])); + let op = Operation::Generate(GenerateRequest::from_protocol_payload(payload)); + let mut stream = Arc::clone(&provider) + .execute( + planned_request_with_presentation("openai", op, model, None), + context(&format!("req_{id}"), CancellationToken::new()), + ) + .await + .unwrap(); + while let Some(event) = stream.next().await { + event.unwrap(); + } + } + let requests = server.received_requests().await.unwrap(); + for (index, expected_role, parent) in [ + (0, None, None), + (1, Some("reviewer"), Some("resp_scope_capture")), + (2, Some("reviewer"), None), + (3, Some("classifier"), Some("resp_scope_capture")), + (4, None, None), + ] { + let request = &requests[index]; + let body = captured_request_body(request); + assert_eq!( + request + .headers + .get("x-codex-guardian") + .map(|h| h.to_str().unwrap()), + expected_role + ); + assert_eq!( + request.headers.contains_key("x-codex-routing-hint"), + expected_role.is_none() + ); + assert_eq!( + body.pointer("/client_metadata/parent_response_id") + .and_then(Value::as_str), + parent + ); + if expected_role.is_some() { + assert!( + body.pointer("/client_metadata/guardian_credits_requested") + .is_none() + ); + } + assert!(!request.headers.contains_key("cookie")); + } +} + #[tokio::test] async fn guardian_parent_pins_require_matching_client_key_and_selected_account() { let store = Arc::new(MemoryAccountStore::default()); @@ -642,11 +925,9 @@ async fn guardian_ignores_expired_ambiguous_and_wrong_path_routing_cookies() { } let requests = server.requests.lock().unwrap(); assert!(!requests[1].1.contains_key("cookie")); - assert!( - requests[1] - .2 - .pointer("/client_metadata/parent_response_id") - .is_none() + assert_eq!( + requests[1].2["client_metadata"]["parent_response_id"], + "parent" ); } } diff --git a/backend/crates/providers/openai/tests/provider/contract/correlation.rs b/backend/crates/providers/openai/tests/provider/contract/correlation.rs index 7da9a6c98..ec82bf231 100644 --- a/backend/crates/providers/openai/tests/provider/contract/correlation.rs +++ b/backend/crates/providers/openai/tests/provider/contract/correlation.rs @@ -9,6 +9,7 @@ const CONTEXT_WINDOW_ID: &str = "3b11bc82-c666-417d-b9ff-2a34fd040385"; fn metadata(window_number: u64) -> Value { json!({"session_id":SESSION_ID, "thread_id":THREAD_ID, "turn_id":"source-turn", "parent_thread_id":SESSION_ID, "forked_from_thread_id":SESSION_ID, + "guardian_classifier_source_thread_id":SESSION_ID, "parent_turn_id":"source-turn", "root_turn_id":"source-turn", "window_id":format!("{THREAD_ID}:{window_number}"), "window_number":window_number, "context_window_id":CONTEXT_WINDOW_ID, "future":{"keep":true}, @@ -197,6 +198,10 @@ async fn account_correlation_preserves_turns_across_transports_and_account_switc } assert_eq!(full["parent_thread_id"], flat["session_id"]); assert_eq!(full["forked_from_thread_id"], flat["session_id"]); + assert_eq!( + full["guardian_classifier_source_thread_id"], + flat["session_id"] + ); let mapped_thread = flat["thread_id"].as_str().unwrap(); let expected_window = format!("{mapped_thread}:{window_number}"); assert_eq!(headers["x-codex-window-id"], expected_window); @@ -390,6 +395,42 @@ async fn image_generation_and_edit_preserve_the_client_turn_identity() { } } +#[tokio::test] +async fn guardian_cache_keys_reference_the_scoped_source_thread_on_http_and_websocket() { + for websocket in [false, true] { + for (source, prefix, cache_id, linked) in [ + ("guardian_review", "guardian", THREAD_ID, true), + ("guardian_classifier", "guardian-v2", THREAD_ID, true), + ("guardian_classifier", "guardian-v2", SESSION_ID, false), + ("guardian_classifier", "custom", THREAD_ID, false), + ("ordinary", "guardian", THREAD_ID, false), + ] { + let cache = format!("{prefix}:{cache_id}"); + let body = capture_downstream_request(json!({ + "model":"gpt-5.4","input":[],"prompt_cache_key":cache,"client_metadata":{ + "x-openai-subagent":"guardian", "x-codex-parent-thread-id":THREAD_ID, + "x-codex-turn-metadata":json!({"thread_source":source, "guardian_classifier_source_thread_id":THREAD_ID}).to_string() + } + }), false, websocket, false).await; + let parent = body["client_metadata"]["x-codex-parent-thread-id"] + .as_str() + .unwrap(); + let turn: Value = serde_json::from_str( + body["client_metadata"]["x-codex-turn-metadata"] + .as_str() + .unwrap(), + ) + .unwrap(); + assert_eq!(turn["guardian_classifier_source_thread_id"], parent); + if linked { + assert_eq!(body["prompt_cache_key"], format!("{prefix}:{parent}")); + } else { + assert_scoped_id(body["prompt_cache_key"].as_str().unwrap(), &cache); + } + } + } +} + #[tokio::test] async fn cache_key_preserves_explicit_sharing_and_omission_within_an_account() { let store = Arc::new(MemoryAccountStore::default()); diff --git a/backend/crates/providers/openai/tests/provider/contract/guardian_model.rs b/backend/crates/providers/openai/tests/provider/contract/guardian_model.rs new file mode 100644 index 000000000..e7a82fce2 --- /dev/null +++ b/backend/crates/providers/openai/tests/provider/contract/guardian_model.rs @@ -0,0 +1,309 @@ +//! 同步审核的结构化身份、热更新路由与上游续接合同 + +use super::*; + +const LUNA: &str = "gpt-5.6-luna"; +const REVIEW: &str = gateway_protocol::openai::CODEX_AUTO_REVIEW_MODEL; +const FUTURE: &str = "custom-review-model"; + +fn reviewer_operation(model: &str, source: &str, subagent: &str, input: Value) -> Operation { + let body = json!({ + "model": model, "input": input, + "client_metadata": { + "x-openai-subagent": subagent, + "x-codex-turn-metadata": json!({"thread_source": source}).to_string() + } + }); + Operation::Generate(GenerateRequest::from_protocol_payload( + ProtocolPayload::json_object("openai", body.as_object().unwrap().clone()) + .unwrap() + .with_context(Map::from_iter([("use_websocket".into(), json!(false))])), + )) +} + +fn settings(enabled: bool) -> SettingsValues { + SettingsValues::new(2, "smart", Default::default(), None, None) + .with_openai_oauth_guardian_review_model(enabled) +} + +fn selected_session(model: &str) -> ProviderSessionState { + ProviderSessionState::new( + "openai", + json!({"account_id":"acct_provider_contract","continuation_scope":"persisted","reviewer_model":model}) + .as_object().unwrap().clone(), + ).unwrap() +} + +fn reviewer_snapshot() -> RuntimeSnapshot { + let provider = ProviderKind::new("openai").unwrap(); + RuntimeSnapshot::new( + ConfigRevision::new(1).unwrap(), + settings(false), + vec![provider.clone()], + [FUTURE, REVIEW] + .map(|model| { + ProviderModel::new( + provider.clone(), + UpstreamModelId::new(model).unwrap(), + ModelCapabilities::new([OperationKind::Generate].into(), Some(32_000)) + .with_upstream_feature_validation(), + ) + }) + .into(), + vec![], + ) + .unwrap() +} + +fn plan_reviewer( + snapshot: &RuntimeSnapshot, + provider: &CodexProvider, + operation: Operation, + previous: Option<&ProviderSessionState>, +) -> ProviderRequest { + let requested = PublicModelId::new(FUTURE).unwrap(); + let openai = ProviderKind::new("openai").unwrap(); + let scope = Arc::new(FrozenAccountScope::new( + Arc::new(RuntimeAccountDirectory::new( + [( + ProviderAccountId::new("acct_provider_contract").unwrap(), + RuntimeAccount::new(openai.clone(), BTreeSet::new()) + .with_direct_authentication_kind(Some("oauth".into())), + )] + .into(), + )), + ClientRoutingScope::all_accounts(), + )); + let context = RoutingContext::default(); + let plan = match provider.direct_account_model( + &requested, + &operation, + previous, + snapshot.settings(), + ) { + Some(target) => snapshot.plan_with_direct_account_model( + &requested, + &operation, + scope, + &context, + gateway_core::routing::DirectAccountModel { + provider: &openai, + model: &target, + continuation_owner: None, + }, + |_| true, + ), + None => snapshot.plan(&requested, &operation, scope, &context), + } + .unwrap(); + ProviderRequest::new(operation, plan.candidates()[0].clone()) +} + +#[tokio::test] +async fn guardian_model_matches_structured_reviewer_and_any_original_model() { + let store = Arc::new(MemoryAccountStore::default()); + let provider = provider(&store); + for requested in [LUNA, FUTURE] { + let model = PublicModelId::new(requested).unwrap(); + for input in [json!([]), json!([{"role": "user", "content": requested}])] { + let op = reviewer_operation(requested, "guardian_review", "guardian", input); + assert!( + provider + .direct_account_model(&model, &op, None, &settings(false)) + .is_none() + ); + assert_eq!( + provider + .direct_account_model(&model, &op, None, &settings(true)) + .unwrap() + .as_str(), + REVIEW + ); + } + } + for (raw_model, routed_model, source, role) in [ + (FUTURE, FUTURE, "guardian_classifier", "guardian"), + (FUTURE, FUTURE, "guardian_housekeeper", "guardian"), + (FUTURE, FUTURE, "guardian_review", "review"), + (FUTURE, FUTURE, "cli", "guardian"), + (REVIEW, REVIEW, "guardian_review", "guardian"), + (FUTURE, "admin-routed", "guardian_review", "guardian"), + ] { + let op = reviewer_operation(raw_model, source, role, json!([])); + assert!( + provider + .direct_account_model( + &PublicModelId::new(routed_model).unwrap(), + &op, + None, + &settings(true), + ) + .is_none() + ); + } +} + +#[tokio::test] +async fn guardian_model_rejects_unknown_or_changed_continuations_before_account_selection() { + let store = Arc::new(MemoryAccountStore::default()); + let provider = provider(&store); + let snapshot = reviewer_snapshot(); + for (enabled, previous) in [(true, None), (true, Some(FUTURE)), (false, Some(REVIEW))] { + let op = continuing_reviewer(previous); + let request = plan_reviewer( + &snapshot.with_settings(&settings(enabled)).unwrap(), + &provider, + op, + None, + ); + let result = Arc::clone(&provider) + .execute(request, external_continuation_context("req_guardian_model")) + .await; + let error = match result { + Err(err) => err, + Ok(_) => panic!("unexpected call"), + }; + assert_eq!( + error.continuation_unavailable_reason(), + Some("review_model_changed") + ); + } +} + +fn continuing_reviewer(previous: Option<&str>) -> Operation { + let Operation::Generate(base) = + reviewer_operation(FUTURE, "guardian_review", "guardian", json!([])) + else { + unreachable!() + }; + let payload = base.protocol_payload(); + let mut body = payload.body().clone(); + body.insert( + "previous_response_id".into(), + json!("external-previous-response"), + ); + let mut request = GenerateRequest::from_protocol_payload( + ProtocolPayload::json_object("openai", body) + .unwrap() + .with_context(payload.context().clone()), + ); + if let Some(previous) = previous { + request = request.with_provider_session_state(selected_session(previous)); + } + Operation::Generate(request) +} + +#[tokio::test] +async fn guardian_samplers_keep_the_http_transport_chosen_by_the_client() { + let store = Arc::new(MemoryAccountStore::default()); + create_account(&store, "acct_provider_contract").await; + let server = MockServer::start().await; + Mock::given(method("POST")) + .and(path("/codex/responses")) + .respond_with( + ResponseTemplate::new(200).set_body_raw(CAPTURE_COMPLETED_SSE, "text/event-stream"), + ) + .expect(2) + .mount(&server) + .await; + let provider = provider_with_base_url(&store, server.uri()); + for turn in [ + json!({"thread_source":"guardian_classifier", "turn_trigger":"guardian_classifier"}), + json!({"turn_trigger":"guardian_housekeeper"}), + ] { + let body = json!({"model":LUNA, "input":[], "stream":true, "store":false, + "client_metadata":{"x-openai-subagent":"guardian", "x-codex-turn-metadata":turn.to_string()}}); + let payload = ProtocolPayload::json_object("openai", body.as_object().unwrap().clone()) + .unwrap() + .with_context(Map::from_iter([ + ("subagent".into(), json!("guardian")), + ("turn_metadata".into(), json!(turn.to_string())), + ])); + let operation = Operation::Generate(GenerateRequest::from_protocol_payload(payload)); + let mut stream = Arc::clone(&provider) + .execute( + planned_request("openai", operation), + context("req_sampler_http", CancellationToken::new()), + ) + .await + .unwrap(); + while let Some(event) = stream.next().await { + event.unwrap(); + } + } + let requests = server.received_requests().await.unwrap(); + assert_eq!( + requests.len(), + 2, + "both sampler POSTs should bypass a fresh WS opening" + ); + assert!( + requests + .iter() + .all(|r| !r.headers.contains_key("content-encoding")) + ); +} + +#[tokio::test] +async fn guardian_model_freezes_the_selected_model_across_settings_changes_and_continuations() { + let store = Arc::new(MemoryAccountStore::default()); + create_account(&store, "acct_provider_contract").await; + let server = MockServer::start().await; + Mock::given(method("POST")) + .and(path("/codex/responses")) + .respond_with( + ResponseTemplate::new(200).set_body_raw(CAPTURE_COMPLETED_SSE, "text/event-stream"), + ) + .expect(4) + .mount(&server) + .await; + let provider = provider_with_base_url(&store, server.uri()); + let off = reviewer_snapshot(); + let on = off.with_settings(&settings(true)).unwrap(); + for (snapshot, previous, expected) in [ + (&off, None, FUTURE), + (&on, None, REVIEW), + (&off, Some(REVIEW), REVIEW), + (&on, Some(FUTURE), FUTURE), + ] { + let operation = match previous { + Some(model) => continuing_reviewer(Some(model)), + None => reviewer_operation( + FUTURE, + "guardian_review", + "guardian", + json!([{"role":"user","content":FUTURE}]), + ), + }; + let request = plan_reviewer( + snapshot, + &provider, + operation, + previous.map(selected_session).as_ref(), + ); + let ctx = if previous.is_some() { + external_continuation_context("req_guardian_wire") + } else { + context("req_guardian_wire", CancellationToken::new()) + }; + let mut stream = Arc::clone(&provider).execute(request, ctx).await.unwrap(); + assert_eq!( + stream.metadata().upstream_model().unwrap().as_str(), + expected + ); + let mut session = None; + while let Some(event) = stream.next().await { + if let Some(state) = event.unwrap().session_update() { + session = state.payload().get("reviewer_model").cloned(); + } + } + assert_eq!(session, Some(json!(expected))); + let sent = captured_request_body(server.received_requests().await.unwrap().last().unwrap()); + assert_eq!(sent["model"], expected); + if previous.is_some() { + assert_eq!(sent["previous_response_id"], "external-previous-response"); + } else { + assert_eq!(sent["input"][0]["content"], FUTURE); + } + } +} diff --git a/backend/crates/providers/openai/tests/provider/contract/mod.rs b/backend/crates/providers/openai/tests/provider/contract/mod.rs index c0d563a2e..4d22aa57b 100644 --- a/backend/crates/providers/openai/tests/provider/contract/mod.rs +++ b/backend/crates/providers/openai/tests/provider/contract/mod.rs @@ -8,6 +8,7 @@ mod catalog_startup; mod cookies; mod correlation; mod error_details; +mod guardian_model; mod image_model_access; mod messages; mod model_account_eligibility; @@ -39,8 +40,8 @@ use chrono::Utc; use futures::{SinkExt, StreamExt, future::BoxFuture}; use gateway_core::account::{ AccountFeedbackStats, AccountWeight, CredentialState, FastMode, OpaqueProviderData, - ProviderAccountId, ProviderAccountStore as _, QuotaAccessChange, QuotaAccessState, - QuotaEvidence, QuotaObservation, QuotaState, + OpenAiRequestCountry, ProviderAccountId, ProviderAccountStore as _, QuotaAccessChange, + QuotaAccessState, QuotaEvidence, QuotaObservation, QuotaState, }; use gateway_core::engine::continuation::{ ContinuationBinding, NativeContinuationPin, PreviousResponseId, @@ -796,7 +797,7 @@ async fn selected_proxy_location_overrides_global_and_reloads_without_mutating_c ].into_iter().enumerate() { let location = location.map(|value| serde_json::from_value::(value).unwrap()); store.set_egress(account_id, Some(OutboundProxy::parse(&proxy.uri()).unwrap()), location); - let mut stream = Arc::clone(&provider).execute(planned_request("openai", operation.clone()), context_with_state_owner_and_location(&format!("req_proxy_location_{index}"), account_id, global_enabled.then(global_request_location))).await.expect("prepare"); + let mut stream = Arc::clone(&provider).execute(planned_request("openai", operation.clone()), context_with_request_settings(&format!("req_proxy_location_{index}"), account_id, global_enabled.then(global_request_location), None, OpenAiRequestCountry::FollowLocation {})).await.expect("prepare"); while let Some(event) = stream.next().await { event.expect("proxy response"); } let requests = proxy.received_requests().await.unwrap(); let body = captured_request_body(requests.last().expect("request reached selected proxy")); @@ -980,6 +981,18 @@ async fn capture_downstream_request( api_key: bool, websocket: bool, lite: bool, +) -> Value { + capture_downstream_with_country(original, api_key, websocket, lite, None, Default::default()) + .await +} + +async fn capture_downstream_with_country( + original: Value, + api_key: bool, + websocket: bool, + lite: bool, + location: Option, + country: OpenAiRequestCountry, ) -> Value { let http = MockServer::start().await; let (base_url, websocket_server) = if websocket { @@ -1046,10 +1059,12 @@ async fn capture_downstream_request( let mut stream = provider .execute( planned_request("openai", operation), - context_with_state_owner_and_location( + context_with_request_settings( "req_replay_compatibility", "acct_provider_contract", + location, None, + country, ), ) .await @@ -1817,14 +1832,21 @@ fn context_with_state_owner_and_location( owner_account_id: &str, location: Option, ) -> AttemptContext { - context_with_state_owner_and_profile(request_id, owner_account_id, location, None) + context_with_request_settings( + request_id, + owner_account_id, + location, + None, + Default::default(), + ) } -fn context_with_state_owner_and_profile( +fn context_with_request_settings( request_id: &str, owner_account_id: &str, location: Option, profile: Option, + country: OpenAiRequestCountry, ) -> AttemptContext { let owner = ProviderAccountStateOwner::new( ProviderKind::new("openai").expect("provider"), @@ -1836,6 +1858,7 @@ fn context_with_state_owner_and_profile( ClientApiKeyId::new("key_openai_contract").expect("client key id"), ) .with_request_location(location) + .with_openai_request_country(country) .with_request_profile(profile), NonZeroU32::new(1).expect("attempt"), SystemTime::now() + Duration::from_secs(30), @@ -6544,11 +6567,12 @@ async fn websocket_account_scoping_keeps_installation_in_metadata() { "openai", Operation::Generate(GenerateRequest::from_protocol_payload(payload)), ), - context_with_state_owner_and_profile( + context_with_request_settings( "req_installation_ws", owner, Some(global_request_location()), Some(profile), + Default::default(), ), ) .await @@ -8213,7 +8237,7 @@ async fn seed_service_tiers(store: &MemoryAccountStore, id: &str, model: &str, t #[tokio::test] async fn responses_should_observe_and_bill_the_outbound_service_tier_on_both_transports() { for use_websocket in [false, true] { - for (fast_mode, advertised_tier, requested, reported, expected_tier, expected_cost) in [ + let regular_cases = [ ( FastMode::Default, None, @@ -8393,7 +8417,40 @@ async fn responses_should_observe_and_bill_the_outbound_service_tier_on_both_tra Some(6_875_000), ), (FastMode::Ultrafast, None, None, None, None, Some(3_437_500)), - ] { + ]; + let guardian_cases = [ + ("reviewer", None, 3_437_500), + ("Reviewer", Some("priority"), 6_875_000), + ("classifier", None, 3_437_500), + ("guardian_classifier", None, 3_437_500), + ("guardian_housekeeper", Some("default"), 3_437_500), + ("guardian_housekeeper", None, 3_437_500), + ] + .map(|(role, expected_tier, cost)| { + ( + Some(role), + ( + FastMode::Enabled, + Some("priority"), + if role == "guardian_housekeeper" { + expected_tier.map(|tier| json!(tier)) + } else { + Some(json!("flex")) + }, + None, + expected_tier, + Some(cost), + ), + ) + }); + for ( + guardian, + (fast_mode, advertised_tier, requested, reported, expected_tier, expected_cost), + ) in regular_cases + .into_iter() + .map(|case| (None, case)) + .chain(guardian_cases) + { let store = Arc::new(MemoryAccountStore::default()); create_account(&store, "acct_provider_contract").await; // 同名模型的聚合画像来自另一个分组,故意与本次能选的账号声明相反 @@ -8439,14 +8496,11 @@ async fn responses_should_observe_and_bill_the_outbound_service_tier_on_both_tra let base_url = format!("http://{}", listener.local_addr().expect("address")); let server = tokio::spawn(async move { let (socket, _) = listener.accept().await.expect("accept WebSocket"); + let mut headers = None; let mut websocket = crate::transport::accept_codex_test_websocket_with( socket, |request, response| { - let expected_hint = expected_tier.map_or_else( - || "model=gpt-5.4".to_owned(), - |tier| format!("model=gpt-5.4;tier={tier}"), - ); - assert_eq!(request.headers()["x-codex-routing-hint"], expected_hint); + headers = Some(request.headers().clone()); response.headers_mut().insert( "sec-websocket-extensions", "permessage-deflate".parse().unwrap(), @@ -8463,7 +8517,7 @@ async fn responses_should_observe_and_bill_the_outbound_service_tier_on_both_tra .await .expect("response"); } - request + (headers.unwrap(), request) }); (base_url, None, Some(server)) } else { @@ -8491,12 +8545,31 @@ async fn responses_should_observe_and_bill_the_outbound_service_tier_on_both_tra if let Some(requested) = &requested { body.insert("service_tier".to_owned(), json!(requested)); } + let mut protocol_context = + Map::from_iter([("use_websocket".to_owned(), json!(use_websocket))]); + if let Some(role) = guardian { + let mut headers = vec![json!([ + "x-codex-routing-hint", + STANDARD.encode("client-hint") + ])]; + if matches!(role, "guardian_classifier" | "guardian_housekeeper") { + let turn = if role == "guardian_classifier" { + json!({"thread_source":role, "turn_trigger":role}) + } else { + json!({"turn_trigger":role}) + }; + body.get_mut("client_metadata").unwrap()["x-openai-subagent"] = + json!("guardian"); + body.get_mut("client_metadata").unwrap()["x-codex-turn-metadata"] = + json!(turn.to_string()); + } else { + headers.push(json!(["x-codex-guardian", STANDARD.encode(role)])); + } + protocol_context.insert("opaque_request_headers".to_owned(), json!(headers)); + } let payload = ProtocolPayload::json_object("openai", body.clone()) .expect("payload") - .with_context(Map::from_iter([( - "use_websocket".to_owned(), - json!(use_websocket), - )])); + .with_context(protocol_context); let operation = Operation::Generate(GenerateRequest::from_protocol_payload(payload)); let original = operation.clone(); let provider = provider_with_catalog_and_base_url(&store, base_url).await; @@ -8541,31 +8614,70 @@ async fn responses_should_observe_and_bill_the_outbound_service_tier_on_both_tra raw_messages.push(message.to_owned()); } } - let outbound = if let Some(server) = http_server { + let (headers, outbound) = if let Some(server) = http_server { server.verify().await; let requests = server.received_requests().await.expect("upstream requests"); - let expected_hint = expected_tier.map_or_else( - || "model=gpt-5.4".to_owned(), - |tier| format!("model=gpt-5.4;tier={tier}"), - ); - assert_eq!(requests[0].headers["x-codex-routing-hint"], expected_hint); - captured_request_body(&requests[0]) + ( + requests[0].headers.clone(), + captured_request_body(&requests[0]), + ) } else { websocket_server .expect("WebSocket server") .await .expect("server task") }; + let expected_hint = matches!(guardian, None | Some("Reviewer")).then(|| { + expected_tier.map_or_else( + || "model=gpt-5.4".to_owned(), + |tier| format!("model=gpt-5.4;tier={tier}"), + ) + }); assert_eq!( - outbound.get("service_tier").and_then(Value::as_str), - expected_tier + headers + .get("x-codex-guardian") + .map(|value| value.to_str().unwrap()), + match guardian { + Some("guardian_classifier") => Some("classifier"), + Some("guardian_housekeeper") => None, + other => other, + } + ); + if !use_websocket + && matches!( + guardian, + Some("classifier" | "guardian_classifier" | "guardian_housekeeper") + ) + { + assert!(headers.get("content-encoding").is_none()); + } + assert_eq!( + headers + .get("x-codex-routing-hint") + .map(|value| value.to_str().unwrap()), + expected_hint.as_deref() + ); + assert_eq!( + outbound.get("service_tier"), + expected_tier.map(|tier| json!(tier)).as_ref() ); assert_eq!(operation, original); for (field, value) in body["client_metadata"] .as_object() .expect("client metadata") { - assert_eq!(&outbound["client_metadata"][field], value); + if field == "x-codex-turn-metadata" { + let sent: Value = + serde_json::from_str(outbound["client_metadata"][field].as_str().unwrap()) + .unwrap(); + let source: Map = + serde_json::from_str(value.as_str().unwrap()).unwrap(); + for (key, value) in source { + assert_eq!(sent[&key], value); + } + } else { + assert_eq!(&outbound["client_metadata"][field], value); + } } assert!(!observations.is_empty()); for observation in &observations { diff --git a/backend/crates/providers/openai/tests/provider/contract/passthrough.rs b/backend/crates/providers/openai/tests/provider/contract/passthrough.rs index b9c8c51c3..1668458b3 100644 --- a/backend/crates/providers/openai/tests/provider/contract/passthrough.rs +++ b/backend/crates/providers/openai/tests/provider/contract/passthrough.rs @@ -93,6 +93,98 @@ async fn responses_options_follow_the_selected_upstream_on_both_transports() { } } +#[tokio::test] +async fn request_country_modes_only_change_the_top_level_across_transports() { + use OpenAiRequestCountry::{Custom, Default, FollowLocation, Passthrough}; + for (api_key, websocket, policy, input, expected) in [ + ( + false, + false, + Default {}, + Some(json!("CA")), + Some(Value::Null), + ), + (true, true, Default {}, None, Some(Value::Null)), + (false, true, Passthrough {}, None, None), + ( + true, + false, + Passthrough {}, + Some(Value::Null), + Some(Value::Null), + ), + ( + false, + false, + Passthrough {}, + Some(json!("CA")), + Some(json!("CA")), + ), + ( + true, + true, + FollowLocation {}, + Some(json!("CA")), + Some(json!("NZ")), + ), + ( + true, + false, + Custom { + country: "JP".into(), + }, + None, + Some(json!("JP")), + ), + ( + false, + true, + Custom { + country: "JP".into(), + }, + Some(Value::Null), + Some(json!("JP")), + ), + ] { + let location = global_request_location(); + let mut body = json!({ + "model": "gpt-5.4", + "input": "hello", + "client_metadata": {"request_country":"business"}, + "tools": [{"type":"web_search"}], + }); + if let Some(input) = input { + body["request_country"] = input; + } + let sent = capture_downstream_with_country( + body, + api_key, + websocket, + false, + Some(location.clone()), + policy, + ) + .await; + assert_eq!(sent.get("request_country"), expected.as_ref()); + assert_eq!( + sent.pointer("/client_metadata/request_country"), + Some(&json!("business")) + ); + assert_eq!( + sent.pointer("/tools/0/user_location/country"), + Some(&json!(location.country)) + ); + assert_eq!( + sent.pointer("/tools/0/user_location/city"), + Some(&json!(location.city)) + ); + assert_eq!( + sent.pointer("/tools/0/user_location/timezone"), + Some(&json!(location.timezone.name())) + ); + } +} + #[tokio::test] async fn codex_oauth_keeps_explicit_context_options() { let body = json!({ diff --git a/backend/crates/providers/openai/tests/provider/contract/upstream_adapter.rs b/backend/crates/providers/openai/tests/provider/contract/upstream_adapter.rs index e21940815..2dc375b36 100644 --- a/backend/crates/providers/openai/tests/provider/contract/upstream_adapter.rs +++ b/backend/crates/providers/openai/tests/provider/contract/upstream_adapter.rs @@ -16,13 +16,12 @@ struct UnmatchedAdapterPlan { impl UpstreamAdapterPlan for UnmatchedAdapterPlan { fn select( &self, - _: &AttemptContext, + route: gateway_core::engine::ModelRouteScope<'_>, provider: &ProviderKind, - model: &UpstreamModelId, _: Option<&ProviderAccountId>, ) -> Result { assert_eq!(provider.as_str(), "openai"); - assert_eq!(model.as_str(), "gpt-5.4"); + assert_eq!(route.model, "gpt-5.4"); self.selections .fetch_add(1, std::sync::atomic::Ordering::SeqCst); Ok(UpstreamAdapterSelection::Native) @@ -185,9 +184,8 @@ struct AdapterProbe { impl gateway_core::engine::upstream_adapter::UpstreamAdapterPlan for AdapterProbe { fn select( &self, - _: &AttemptContext, + _: gateway_core::engine::ModelRouteScope<'_>, provider: &ProviderKind, - _: &UpstreamModelId, _: Option<&ProviderAccountId>, ) -> Result { assert_eq!(provider.as_str(), "openai"); @@ -359,9 +357,8 @@ impl std::fmt::Debug for AffinityAdapterProbe { impl UpstreamAdapterPlan for AffinityAdapterProbe { fn select( &self, - _: &AttemptContext, + _: gateway_core::engine::ModelRouteScope<'_>, _: &ProviderKind, - _: &UpstreamModelId, account: Option<&ProviderAccountId>, ) -> Result { if self.account_scoped { @@ -756,9 +753,8 @@ struct AccountScopedProbe { impl UpstreamAdapterPlan for AccountScopedProbe { fn select( &self, - _: &AttemptContext, + _: gateway_core::engine::ModelRouteScope<'_>, _: &ProviderKind, - _: &UpstreamModelId, account: Option<&ProviderAccountId>, ) -> Result { let Some(account) = account else { @@ -994,9 +990,8 @@ impl std::fmt::Debug for ConnectionProbe { impl UpstreamAdapterPlan for ConnectionProbe { fn select( &self, - _: &AttemptContext, + _: gateway_core::engine::ModelRouteScope<'_>, _: &ProviderKind, - _: &UpstreamModelId, _: Option<&ProviderAccountId>, ) -> Result { Ok(UpstreamAdapterSelection::Adapter(Arc::new(Self { diff --git a/backend/crates/providers/openai/tests/transport/headers.rs b/backend/crates/providers/openai/tests/transport/headers.rs index bfe256d26..167081101 100644 --- a/backend/crates/providers/openai/tests/transport/headers.rs +++ b/backend/crates/providers/openai/tests/transport/headers.rs @@ -158,6 +158,7 @@ async fn backend_websocket_should_forward_context_headers_and_preserve_payload_f ], ); request.use_websocket = true; + request.turn_state = Some("turn-state".to_owned()); request.responses_lite = Some("true".to_owned()); request.memgen_request = Some("true".to_owned()); request.set_client_metadata(Some(json!({ @@ -217,11 +218,11 @@ async fn backend_websocket_should_forward_context_headers_and_preserve_payload_f .and_then(Value::as_str) .is_some_and(|value| value.parse::().is_ok_and(|value| value > 0)) ); + assert_eq!(metadata["x-codex-turn-state"], "turn-state"); let headers = received_headers.lock().expect("headers lock"); for (name, expected) in [ ("x-client-request-id", "cp_derived"), ("openai-beta", "responses_websockets=2026-02-06"), - ("x-codex-turn-state", "turn-state"), ("x-codex-turn-metadata", "{\"thread_source\":\"subagent\"}"), ("x-codex-beta-features", "feature-a"), ("x-responsesapi-include-timing-metrics", "true"), @@ -244,6 +245,7 @@ async fn backend_websocket_should_forward_context_headers_and_preserve_payload_f } } for forbidden in [ + "x-codex-turn-state", "x-codex-installation-id", "x-codex-turn-id", "x-openai-internal-codex-residency", diff --git a/backend/crates/providers/openai/tests/transport/latency.rs b/backend/crates/providers/openai/tests/transport/latency.rs index f3d1f6089..f20bb74dd 100644 --- a/backend/crates/providers/openai/tests/transport/latency.rs +++ b/backend/crates/providers/openai/tests/transport/latency.rs @@ -234,8 +234,18 @@ async fn cold_websocket_should_fall_back_without_recording_a_successful_connect( assert!(opening.starts_with("GET /codex/responses HTTP/1.1")); let (mut http, _) = listener.accept().await.unwrap(); - let request = read_http_request(&mut http).await; - assert!(request.starts_with("POST /codex/responses HTTP/1.1")); + let request = read_http_request_with_body(&mut http).await; + assert!(request.starts_with(b"POST /codex/responses HTTP/1.1")); + let separator = request + .windows(4) + .position(|bytes| bytes == b"\r\n\r\n") + .unwrap(); + let body = zstd::stream::decode_all(&request[separator + 4..]).unwrap(); + let body: Value = serde_json::from_slice(&body).unwrap(); + assert!( + body.pointer("/client_metadata/x-codex-ws-stream-request-start-ms") + .is_none() + ); write_completed_sse_response(&mut http).await; }); let pool = Arc::new(CodexWebSocketPool::default()); @@ -266,6 +276,21 @@ async fn cold_websocket_should_fall_back_without_recording_a_successful_connect( pool.shutdown().await; } +fn assert_ws_start_after(payload: &Value, boundary: std::time::SystemTime) { + let start_ms = payload["client_metadata"]["x-codex-ws-stream-request-start-ms"] + .as_str() + .unwrap() + .parse::() + .unwrap(); + assert!( + start_ms + >= boundary + .duration_since(std::time::UNIX_EPOCH) + .unwrap() + .as_millis() + ); +} + #[tokio::test] async fn downstream_websocket_new_chain_should_preserve_continuation_after_slow_opening() { let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); @@ -282,8 +307,12 @@ async fn downstream_websocket_new_chain_should_preserve_continuation_after_slow_ return; } } + let opening_start = std::time::SystemTime::now(); let mut websocket = accept_codex_test_websocket(stream).await; - let _first = websocket.next().await.unwrap().unwrap(); + let first = websocket.next().await.unwrap().unwrap(); + let first: Value = serde_json::from_str(first.to_text().unwrap()).unwrap(); + assert_ws_start_after(&first, opening_start); + let next_turn_start = std::time::SystemTime::now(); websocket .send(Message::Text( completed_websocket_response("resp_slow_seed", 2, 1).into(), @@ -294,6 +323,7 @@ async fn downstream_websocket_new_chain_should_preserve_continuation_after_slow_ let second = websocket.next().await.unwrap().unwrap(); let second: Value = serde_json::from_str(second.to_text().unwrap()).unwrap(); assert_eq!(second["previous_response_id"], "resp_slow_seed"); + assert_ws_start_after(&second, next_turn_start); websocket .send(Message::Text( completed_websocket_response("resp_slow_continuation", 2, 1).into(), diff --git a/backend/crates/providers/xai/tests/provider/contract/mod.rs b/backend/crates/providers/xai/tests/provider/contract/mod.rs index 76298eee5..f021a443d 100644 --- a/backend/crates/providers/xai/tests/provider/contract/mod.rs +++ b/backend/crates/providers/xai/tests/provider/contract/mod.rs @@ -4368,9 +4368,8 @@ struct AdapterProbe { impl gateway_core::engine::upstream_adapter::UpstreamAdapterPlan for AdapterProbe { fn select( &self, - _: &AttemptContext, + _: gateway_core::engine::ModelRouteScope<'_>, provider: &ProviderKind, - _: &UpstreamModelId, account: Option<&ProviderAccountId>, ) -> Result { assert_eq!(provider.as_str(), "xai"); diff --git a/backend/crates/providers/xai/tests/provider/contract/scheduling.rs b/backend/crates/providers/xai/tests/provider/contract/scheduling.rs index df799b5bb..a04668fa9 100644 --- a/backend/crates/providers/xai/tests/provider/contract/scheduling.rs +++ b/backend/crates/providers/xai/tests/provider/contract/scheduling.rs @@ -83,9 +83,8 @@ struct AccountEligibilityPlan { impl gateway_core::engine::upstream_adapter::UpstreamAdapterPlan for AccountEligibilityPlan { fn select( &self, - _: &AttemptContext, + _: gateway_core::engine::ModelRouteScope<'_>, _: &ProviderKind, - _: &UpstreamModelId, account: Option<&ProviderAccountId>, ) -> Result { let Some(account) = account else { diff --git a/backend/migrations/.frozen-sha256 b/backend/migrations/.frozen-sha256 index 92f021115..a4bb46f51 100644 --- a/backend/migrations/.frozen-sha256 +++ b/backend/migrations/.frozen-sha256 @@ -43,3 +43,4 @@ aeff99fee7cef5a553ae49ffe27a48f49e31ccfb3fbc61a2482c9b109478202d 0041_account_m 223589308df852154004385b13c91a03714114fb9472f00472099bcf2c131cb3 0043_quota_reset_window_weights.sql 23eeb6ef99de2315cf4a198638e9c73b364fb1cb40b7e571a3f15d3e9d15f67c 0044_account_quota_settings.sql 4e4415d21e951f4ce6cddebfd485032dd33d241dd7d9e9ed9b45b3a10f8e3878 0045_account_group_policies.sql +d7f87d6f16c40d62b852cd39e59454d0a509c328508494f66cfd98d38b797c21 0046_openai_request_settings.sql diff --git a/backend/migrations/0046_openai_request_settings.sql b/backend/migrations/0046_openai_request_settings.sql new file mode 100644 index 000000000..a6f8b3c2d --- /dev/null +++ b/backend/migrations/0046_openai_request_settings.sql @@ -0,0 +1,13 @@ +-- 默认启用 OAuth 同步审核专用模型,请求国家跟随位置 +alter table runtime_settings + add column openai_oauth_guardian_review_model boolean not null default true, + add column openai_request_country_json jsonb not null default '{"mode":"follow_location"}'::jsonb, + add constraint runtime_settings_openai_request_country_ck check ( + openai_request_country_json in ('{"mode":"default"}', '{"mode":"passthrough"}', '{"mode":"follow_location"}') + or ( + openai_request_country_json ?& array['mode', 'country'] + and openai_request_country_json = jsonb_build_object('mode', 'custom', 'country', openai_request_country_json->>'country') + and (openai_request_country_json->>'country') collate "C" ~ '^[A-Z]{2}$' + and jsonb_typeof(openai_request_country_json->'country') = 'string' + ) + ); diff --git a/deploy/README.md b/deploy/README.md index 1c0b96acd..6ed859009 100644 --- a/deploy/README.md +++ b/deploy/README.md @@ -418,6 +418,8 @@ PostgreSQL/Redis 启动密码。日常校验使用 `config --quiet` | 并发与排队 | “系统设置 → 运行设置”;Key 与账号分别设置排队容量和超时,可选择账号排队失败后换号,见[排队规则](../docs/api.md#并发与排队) | | 账号错误保护 | “系统设置 → 运行设置 → 错误保护”;默认关闭,按[自定义规则](../docs/api.md#账号错误保护)暂停账号调度 | | 全局请求位置 | “系统设置 → 上游配置 → 请求位置覆盖”,默认关闭 | +| OpenAI 请求国家 | “系统设置 → 上游配置 → 请求位置覆盖”中默认选中“跟随位置”,可选择“空值”“透传”或“自定义” | +| OpenAI OAuth 同步审核模型 | “系统设置 → 上游配置 → 模型映射”中的“专用审核模型”默认开启,关闭后沿用客户端模型。[适用条件](../docs/api.md#正文兼容) | | 代理位置 | “代理管理”;优先于全局位置,全局关闭时仍可独立生效 | 位置覆盖只影响 OpenAI 请求中受支持的位置与时区信息,不改变上下文日期、真实出口 IP、epoch 时间戳或系统时区。 diff --git a/docs/api.md b/docs/api.md index 00779cc62..a1006c576 100644 --- a/docs/api.md +++ b/docs/api.md @@ -510,7 +510,9 @@ Responses 的安装身份通过正文 `client_metadata` 及 turn metadata 发送 `x-openai-internal-codex-residency` 和 `x-openai-account-routing-override` 分别由部署配置 `openai.residency`、`openai.account_routing_override` 控制,配置值原样发送并覆盖客户端同名头, 省略或 `null` 时删除对应请求头。配置说明见 [部署与运维](../deploy/README.md#启动后的运行设置) -`x-openai-fedramp` 默认按业务头透传并保留原始多值,Responses 明确换号时清理。 +`x-openai-fedramp` 默认按业务头透传并保留原始多值,Responses 明确换号时清理客户端值。 +所选 OpenAI OAuth 令牌声明 FedRAMP 时,网关为模型请求设置唯一的 `x-openai-fedramp: true`。 +同账号轮换令牌导致该声明变化时,新请求使用新的上游 WS 连接,旧连接上的精确续接需要客户端重放。 上述过滤描述原生转发;已信任插件的显式 header 改写可以覆盖账号与画像生成的默认头, 不按认证或会话字段名称拦截,边界见 [SDK 请求中间件](../backend/crates/gateway-plugin/sdk/docs/capabilities.md#模型请求与-attempt) @@ -536,6 +538,8 @@ HTTP 请求头、正文 metadata、WS 副本及已识别的 Desktop 自动 Git Images 的 `x-codex-image-turn-id` 和 Desktop 自动 Git 上下文的 `clientUserMessageId`。 输入项元数据保持不变。Search 的会话 `id` 按同一安装身份域映射,只替换该值的原始字节,其余正文保持不变。 `prompt_cache_key` 同样按安装身份映射,保留同一身份内的缓存共享关系;未提供时不补造。 +官方 Guardian 缓存键中的 UUID 与本次父线程或分类来源线程匹配时,保留 `guardian:` 或 +`guardian-v2:` 前缀并映射同一线程 UUID。其他缓存键按整个值映射。 受信任插件可读取原始请求,自行生成身份并在 `outbound` 改写完整请求与关联字段;宿主不重新派生或补回业务字段, 实际选号与计费归属保持不变,详见 [SDK 出站请求准备](../backend/crates/gateway-plugin/sdk/docs/capabilities.md#上游出站准备)。 续接 response ID、历史 item/call ID、业务正文和未知扩展不参与映射, @@ -546,7 +550,8 @@ WS 握手的轮次元数据头只随首次请求转发,后续帧在正文中 `x-codex-beta-features` 和 `x-responsesapi-include-timing-metrics` 按原始请求头透传 `x-codex-turn-state` 是上游签发的轮次路由 token。客户端在同一轮原样回传,新轮次省略。 -网关转发当前请求提供的值,明确换账号时清除。WS 握手携带的值只用于首次请求,当前帧提供的值优先。 +网关转发当前请求提供的值,明确换账号时清除。客户端 WS 握手携带的值只用于首次请求,当前帧提供的值优先。 +连接 Codex OAuth 上游时,该值写入当前 `response.create` 帧的 `client_metadata`,新上游 WS 握手省略此头。 续接 response ID 及其他账号状态的归属独立校验 #### 正文兼容 @@ -582,13 +587,25 @@ WS 握手的轮次元数据头只随首次请求转发,后续帧在正文中 turn metadata 的 `workspaces` 也会保留仓库绝对路径、Git 远端地址、提交及工作区变更状态; 安装身份和账号绑定字段的处理不提供这些信息的脱敏 -`client_metadata.parent_response_id` 是 Guardian 的账号内响应引用,只有归属可信且仍为同一账号时保留; -切号或归属未知时移除。`x-codex-guardian`、`guardian_credits_requested` 和序列化 -`x-codex-turn-metadata` 内普通扩展的同名 `parent_response_id` 保持原样 +Codex 客户端按本地登录方式和模型卡选择同步 Guardian 审核模型。使用默认模型卡时, +API Key 登录通常选择 `gpt-5.6-luna`,ChatGPT 登录选择 `codex-auto-review`。 +“系统设置 → 上游配置”中的“专用审核模型”默认开启。关闭后沿用客户端模型。开启时,网关按当前请求的 +Guardian 身份识别同步审核和审核预热,优先选择允许 `codex-auto-review` 的原生 OAuth 账号。 +入站审核模型可以是任意名称。普通请求、后台分类和会话整理沿用原模型。 +缺少合格账号时,网关按客户端模型正常选路。管理员显式模型映射、别名与已绑定的适配器和中间件优先。 +已有续接沿用绑定账号及已记录的审核模型;无法确认模型兼容性时要求客户端重放。执行开始后的重试保持已选模型 -同一 Client Key、同一 OAuth 账号的 Guardian 请求可利用网关记录的父响应 WS 握手信息, -尽力复用父请求的上游路由。路由 Cookie 仅在网关与上游之间使用,不传给客户端; -网关重启、记录淘汰或 Cookie 到期后仍可按普通路由请求,不保证上游路由亲和 +发往 Codex OAuth 的同步 `codex-auto-review` 审核带 `x-codex-guardian: reviewer`, +后台分类带 `x-codex-guardian: classifier`。这两类请求都省略顶层 `service_tier` 和 +`x-codex-routing-hint`,分组强制加速同样适用。后台会话整理保留会话层级并省略上述两个请求头。 +后台分类和会话整理的 HTTP 请求使用未压缩 JSON。普通 OAuth 生成和同步审核的 HTTP 正文使用 zstd + +同步审核和后台分类的 `client_metadata.parent_response_id` 只有在网关记录能确认同一 Client Key、 +同一 OAuth 账号的父响应时才发送,HTTP 和 WS 收到的父响应都可验证。预热请求可以没有父响应。 +同步审核可复用该父响应有效的上游 WS 路由 Cookie。缺少可用 Cookie 时仍可发送已验证的父响应 ID; +父响应记录淘汰或网关重启后,网关省略该 ID 并继续审核。 +网关保留父会话发来的 `guardian_credits_requested`,不会根据账号类型补造该字段,已识别的 +Guardian 子请求会移除它。序列化 turn metadata 内普通扩展的同名字段保持原样 #### WebSocket 与上游传输 @@ -600,6 +617,9 @@ Responses WebSocket 接受文本消息,`response.create` 在同一连接串行 留在有界接收队列中,待当前响应完成终结和写出后再逐条校验、准入与执行,不因请求提前到达而断开。 接收队列容量为 32 个事件,超载仍关闭连接;Ping/Pong、客户端关闭和服务关闭不等待队列中的请求执行 +原生上游 WS 帧里的 `x-codex-ws-stream-request-start-ms` 在连接可用后、发送前写入。 +如果出站插件接管了帧正文,网关按插件返回的字节发送,保留其签名和时间戳 + 网关分别维护两段链路的心跳:上游 WS 定时发送 Ping 保活并回复 Pong,下游 WS 独立探活;Ping/Pong 不跨段转发,也不转换为 SSE 事件。 下游探活包含消息接收中的字节进度,完整消息收齐后才进入中间件与请求处理。 客户端断开时取消当前执行,并释放仍归该客户端所有的上游连接。`response.completed` 结束本轮响应。通常保留客户端 WS 等待下一轮请求,大包回退后的重连规则见下文 @@ -1487,7 +1507,7 @@ API 的 `autoLocation` 默认为 `false`;开启时使用已检测位置,测 只改位置不清空连通性测试结果,也不更改账号凭据版本 关联账号的 OpenAI/Codex Responses 请求(HTTP/SSE、WebSocket)优先使用代理位置,否则使用全局 -运行设置中已开启的 `requestLocation`。出站正文的顶层 `request_country` 始终写入生效位置的两位国家码,无位置覆盖时写入 JSON `null`。 +运行设置中已开启的 `requestLocation`。出站正文的顶层 `request_country` 默认跟随位置,也可在[请求位置](#请求位置)选择“空值”“透传”或“自定义”。 位置覆盖同时更新客户端时间上下文的时区和 Web Search 的结构化位置,未启用覆盖时这两项保留客户端原值。 全局覆盖按请求冻结,保存后对新请求生效。代理覆盖按每次执行选定的账号解析,包括换号和换出口。 位置覆盖不改变 epoch 时间戳、真实出口 IP、服务或管理端时区、数据驻留约束及 xAI 请求 @@ -2203,7 +2223,8 @@ HTTP 返回 `429`,`error.code` 为 `key_daily_budget_exceeded` 或 `key_weekly | --- | --- | | 并发控制版本 | `configRevision` | | [客户端身份](#provider-客户端身份) | `providerRequestProfiles`、`openaiClientProfile`、`xaiClientProfile` | -| [请求位置](#请求位置) | `requestLocationEnabled`、`requestLocation` | +| [请求位置](#请求位置) | `requestLocationEnabled`、`requestLocation`、`openaiRequestCountry` | +| [OpenAI OAuth 同步审核模型](#正文兼容) | `openaiOauthGuardianReviewModel`,默认 `true` | | [隐私策略](#隐私策略) | `codexPrivacyPolicy` | | 模型映射 | `modelMappings` | | 凭据刷新 | `refreshMarginSeconds`、`refreshConcurrency` | @@ -2253,6 +2274,17 @@ HTTP 返回 `429`,`error.code` 为 `key_daily_budget_exceeded` 或 `key_weekly 关联代理配置了自定义位置时优先使用代理值。保存后通过现有配置发布机制对新请求生效, 已开始请求及其重试保持同一份全局值;普通文本、绝对时间戳和数据驻留要求不受影响 +`openaiRequestCountry` 单独控制 OpenAI Responses 出站正文顶层的 `request_country`。保存后对新请求生效。 + +| 管理端选项 | 设置值 | 发往上游的字段 | +| --- | --- | --- | +| 跟随位置 | `{"mode":"follow_location"}` | 默认选项。先取代理位置,再取已开启的全局位置。两者都没有时发送 `null` | +| 空值 | `{"mode":"default"}` | 始终发送 `"request_country": null`,包括客户端传入国家、代理或全局位置已配置的情况 | +| 透传 | `{"mode":"passthrough"}` | 保留客户端原值,包括显式 `null`;客户端省略时也省略 | +| 自定义 | `{"mode":"custom","country":"CA"}` | 始终发送指定的两位大写 ASCII 国家码,独立于城市、时区和全局位置开关 | + +更新设置时省略 `openaiRequestCountry` 或 `openaiOauthGuardianReviewModel`,对应值保持上次保存的设置。 + ### 隐私策略 `codexPrivacyPolicy` 为必填对象,默认 `{ enabled: false, onError: "skip_rule", rules: [] }`。 diff --git a/frontend/src/api/modules/settings/index.ts b/frontend/src/api/modules/settings/index.ts index 95b5f45b8..a66823f1e 100644 --- a/frontend/src/api/modules/settings/index.ts +++ b/frontend/src/api/modules/settings/index.ts @@ -39,6 +39,10 @@ export interface SmartSchedulingConfig { resetWindowWeights: ResetWindowWeights } +export type OpenAiRequestCountry + = | { mode: 'default' | 'passthrough' | 'follow_location' } + | { mode: 'custom', country: string } + export interface RuntimeSettings { configRevision: number smartScheduling: SmartSchedulingConfig @@ -50,8 +54,10 @@ export interface RuntimeSettings { xaiClientProfile: XaiClientProfileSelection | null codexPrivacyPolicy: CodexPrivacyPolicy + openaiRequestCountry: OpenAiRequestCountry requestLocationEnabled: boolean requestLocation: RequestLocation + openaiOauthGuardianReviewModel: boolean modelMappings: Record refreshMarginSeconds: number refreshConcurrency: number diff --git a/frontend/src/components/CountryCodeField.vue b/frontend/src/components/CountryCodeField.vue new file mode 100644 index 000000000..1a14fcd5e --- /dev/null +++ b/frontend/src/components/CountryCodeField.vue @@ -0,0 +1,24 @@ + + + diff --git a/frontend/src/components/HelpPopover.vue b/frontend/src/components/HelpPopover.vue index 934068117..d6b0b66cb 100644 --- a/frontend/src/components/HelpPopover.vue +++ b/frontend/src/components/HelpPopover.vue @@ -2,7 +2,7 @@ import { ZIconButton, ZPopover } from '@codex-proxy/ui' import { CircleAlert } from '@lucide/vue' -defineProps<{ label: string, content: string }>() +defineProps<{ label: string, content?: string }>() diff --git a/frontend/src/components/RequestLocationFields.vue b/frontend/src/components/RequestLocationFields.vue index 6aebd8cc5..af83fc6bd 100644 --- a/frontend/src/components/RequestLocationFields.vue +++ b/frontend/src/components/RequestLocationFields.vue @@ -5,6 +5,7 @@ import type { RequestLocation } from '@/api' import { ZFormItem, ZInput } from '@codex-proxy/ui' import { computed } from 'vue' import { useI18n } from 'vue-i18n' +import CountryCodeField from '@/components/CountryCodeField.vue' defineProps<{ disabled?: boolean, formProp?: string }>() @@ -17,15 +18,6 @@ const requiredRule = computed(() => ({ trigger: ['blur', 'change'], message: t('common.location.required'), })) -const countryRules = computed(() => [ - requiredRule.value, - { - pattern: /^[A-Z]{2}$/, - transform: value => value.trim().toUpperCase(), - trigger: ['blur', 'change'], - message: t('common.location.required'), - }, -]) function update(field: keyof RequestLocation, value: string) { location.value = { ...location.value, [field]: value } @@ -34,9 +26,13 @@ function update(field: keyof RequestLocation, value: string) {