mirror of
https://github.com/zyycn/codex-proxy-rs.git
synced 2026-11-21 16:01:32 +00:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
4ee9abf9d2 | ||
|
|
779ccf4e6c | ||
|
|
d13a4a2138 | ||
|
|
a0e7f38f7f | ||
|
|
41f97ac836 | ||
|
|
975b73b33b | ||
|
|
d787195f4e | ||
|
|
8681d6851e | ||
|
|
d99ecf9aaf | ||
|
|
8f40bfda7c | ||
|
|
72215fe62a | ||
|
|
f61995e61d | ||
|
|
f85d80d756 | ||
|
|
e1f84c210b | ||
|
|
0e02a056b5 | ||
|
|
1eac929e9d | ||
|
|
9b4a042be5 | ||
|
|
3bd042181e | ||
|
|
2cae28d7f4 | ||
|
|
bab781cbe0 |
Generated
+6
-6
@@ -3492,9 +3492,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "quinn-proto"
|
||||
version = "0.11.18"
|
||||
version = "0.11.19"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a9746dbde176634f4f2f1faf2404e30a31b2bc1e9cafb5329c95d8177a18c9fc"
|
||||
checksum = "0e750cca55fe4f0439a15d0bb529da9651e79993e8e72c61a899a36d462befbe"
|
||||
dependencies = [
|
||||
"bytes",
|
||||
"getrandom 0.4.3",
|
||||
@@ -3514,9 +3514,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "quinn-udp"
|
||||
version = "0.5.15"
|
||||
version = "0.5.16"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "35a133f956daabe89a61a685c2649f13d82d5aa4bd5d12d1277e1072a21c0694"
|
||||
checksum = "af66907df18639dcf4db56ca65490cabc4b27a97dbadd96f2926cca73298f016"
|
||||
dependencies = [
|
||||
"cfg_aliases",
|
||||
"libc",
|
||||
@@ -3827,9 +3827,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "rustix"
|
||||
version = "1.1.4"
|
||||
version = "1.1.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
|
||||
checksum = "e5e76742e5294153d4dde1207dbec5bdd81eef6fabdc0d2118babadabfd858aa"
|
||||
dependencies = [
|
||||
"bitflags",
|
||||
"errno",
|
||||
|
||||
@@ -24,7 +24,7 @@ impl RetentionPolicy {
|
||||
audit_days: u32,
|
||||
) -> Result<(), &'static str> {
|
||||
for (valid, field) in [
|
||||
((1..=31).contains(&usage_days), "usage_retention_days"),
|
||||
(usage_days > 0, "usage_retention_days"),
|
||||
(ops_days > 0, "ops_event_retention_days"),
|
||||
(audit_days > 0, "audit_retention_days"),
|
||||
] {
|
||||
@@ -38,7 +38,7 @@ impl RetentionPolicy {
|
||||
pub fn try_new(usage_days: u32, ops_days: u32, audit_days: u32) -> Result<Self, AdminError> {
|
||||
if Self::validate_values(usage_days, ops_days, audit_days).is_err() {
|
||||
return Err(AdminError::invalid(
|
||||
"请求保留期必须为 1~31 天,事件与审计保留期必须为正数",
|
||||
"请求、事件与审计保留期必须为正整数天数",
|
||||
));
|
||||
}
|
||||
Ok(Self {
|
||||
|
||||
@@ -63,6 +63,7 @@ pub struct RuntimeSettingsValues {
|
||||
pub openai_session_affinity_ttl_hours: u32,
|
||||
pub responses_max_decompressed_body_bytes: u64,
|
||||
pub smart_scheduling: gateway_core::account::SmartSchedulingConfig,
|
||||
pub quota_reset_window_weights: gateway_core::account::ResetWindowWeights,
|
||||
pub min_codex_desktop_version: Option<String>,
|
||||
pub min_codex_cli_version: Option<String>,
|
||||
pub usage_retention_days: u32,
|
||||
|
||||
@@ -3,25 +3,15 @@
|
||||
use gateway_admin::model::retention::{RetentionPolicy, RetentionTarget};
|
||||
|
||||
#[test]
|
||||
fn retention_policy_rejects_invalid_windows_and_preserves_independent_windows() {
|
||||
for (usage, ops, audit) in [
|
||||
(0, 1, 1),
|
||||
(32, 1, 1),
|
||||
(u32::MAX, 1, 1),
|
||||
(1, 0, 1),
|
||||
(1, 1, 0),
|
||||
] {
|
||||
fn retention_policy_rejects_zero_for_each_target() {
|
||||
for (usage, ops, audit) in [(0, 1, 1), (1, 0, 1), (1, 1, 0)] {
|
||||
assert!(RetentionPolicy::try_new(usage, ops, audit).is_err());
|
||||
}
|
||||
let policy = RetentionPolicy::try_new(31, 7, 90).unwrap();
|
||||
assert_eq!(policy.days(RetentionTarget::ModelRequests), 31);
|
||||
assert_eq!(policy.days(RetentionTarget::OpsEvents), 7);
|
||||
assert_eq!(policy.days(RetentionTarget::AdminAuditEvents), 90);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn request_retention_accepts_short_windows_without_changing_other_targets() {
|
||||
for days in [1, 3, 7, 15, 30, 31] {
|
||||
fn request_retention_accepts_positive_windows_without_changing_other_targets() {
|
||||
for days in [1, 31, 32, 365, 3650, u32::MAX] {
|
||||
let policy = RetentionPolicy::try_new(days, 30, 90).unwrap();
|
||||
assert_eq!(policy.days(RetentionTarget::ModelRequests), days);
|
||||
assert_eq!(policy.days(RetentionTarget::OpsEvents), 30);
|
||||
|
||||
@@ -1180,6 +1180,7 @@ impl SettingsStore for StaticSettingsStore {
|
||||
openai_session_affinity_ttl_hours: 24,
|
||||
responses_max_decompressed_body_bytes: 64 * 1024 * 1024,
|
||||
smart_scheduling: gateway_core::account::SmartSchedulingConfig::default(),
|
||||
quota_reset_window_weights: gateway_core::account::ResetWindowWeights::default(),
|
||||
min_codex_desktop_version: None,
|
||||
min_codex_cli_version: None,
|
||||
usage_retention_days: 30,
|
||||
|
||||
@@ -51,6 +51,7 @@ fn runtime_settings(enabled: bool, probe_enabled: bool) -> RuntimeSettings {
|
||||
openai_session_affinity_ttl_hours: 24,
|
||||
responses_max_decompressed_body_bytes: 64 * 1024 * 1024,
|
||||
smart_scheduling: gateway_core::account::SmartSchedulingConfig::default(),
|
||||
quota_reset_window_weights: gateway_core::account::ResetWindowWeights::default(),
|
||||
min_codex_desktop_version: None,
|
||||
min_codex_cli_version: None,
|
||||
usage_retention_days: 31,
|
||||
|
||||
@@ -1432,6 +1432,7 @@ impl SettingsStore for FixtureSettingsStore {
|
||||
openai_session_affinity_ttl_hours: 24,
|
||||
responses_max_decompressed_body_bytes: 64 * 1024 * 1024,
|
||||
smart_scheduling: gateway_core::account::SmartSchedulingConfig::default(),
|
||||
quota_reset_window_weights: gateway_core::account::ResetWindowWeights::default(),
|
||||
min_codex_desktop_version: None,
|
||||
min_codex_cli_version: None,
|
||||
usage_retention_days: 31,
|
||||
|
||||
@@ -257,8 +257,8 @@ fn sdk_settings_contract_matches_host_declarations() {
|
||||
&["RequestLocation"][..],
|
||||
),
|
||||
(
|
||||
"../gateway-core/src/account/smart_scheduling.rs",
|
||||
&["SmartSchedulingValues", "ResetWindowWeights"][..],
|
||||
"../gateway-core/src/account/scheduling.rs",
|
||||
&["SmartSchedulingValues", "ResetWindowValues"][..],
|
||||
),
|
||||
(
|
||||
"../gateway-core/src/metering/pricing.rs",
|
||||
@@ -326,10 +326,10 @@ fn sdk_settings_contract_matches_host_declarations() {
|
||||
}
|
||||
types.push(contract_type(
|
||||
item,
|
||||
if *name == "SmartSchedulingValues" {
|
||||
"SmartSchedulingConfig"
|
||||
} else {
|
||||
name
|
||||
match *name {
|
||||
"SmartSchedulingValues" => "SmartSchedulingConfig",
|
||||
"ResetWindowValues" => "ResetWindowWeights",
|
||||
_ => name,
|
||||
},
|
||||
));
|
||||
}
|
||||
|
||||
@@ -343,6 +343,8 @@ async fn settings_should_reject_zero_refresh_margin_before_store_call() {
|
||||
openai_session_affinity_ttl_hours: 24,
|
||||
responses_max_decompressed_body_bytes: 64 * 1024 * 1024,
|
||||
smart_scheduling: gateway_core::account::SmartSchedulingConfig::default(),
|
||||
quota_reset_window_weights: gateway_core::account::ResetWindowWeights::default(
|
||||
),
|
||||
min_codex_desktop_version: None,
|
||||
min_codex_cli_version: None,
|
||||
usage_retention_days: 31,
|
||||
|
||||
@@ -54,6 +54,7 @@ pub struct RuntimeSettingsFields {
|
||||
pub openai_session_affinity_ttl_hours: u32,
|
||||
pub responses_max_decompressed_body_bytes: u64,
|
||||
pub smart_scheduling: gateway_core::account::SmartSchedulingConfig,
|
||||
pub quota_reset_window_weights: gateway_core::account::ResetWindowWeights,
|
||||
pub min_codex_desktop_version: Option<String>,
|
||||
pub min_codex_cli_version: Option<String>,
|
||||
pub usage_retention_days: u64,
|
||||
@@ -77,6 +78,7 @@ pub struct RuntimeSettingsView {
|
||||
pub values: RuntimeSettingsFields,
|
||||
pub config_revision: u64,
|
||||
pub smart_scheduling_defaults: gateway_core::account::SmartSchedulingConfig,
|
||||
pub quota_reset_window_weights_defaults: gateway_core::account::ResetWindowWeights,
|
||||
pub provider_request_profiles: ProviderRequestProfiles,
|
||||
/// 固定兼容字段;值始终从 provider_request_profiles 派生
|
||||
pub openai_client_profile: Option<serde_json::Map<String, serde_json::Value>>,
|
||||
@@ -150,6 +152,8 @@ impl From<(RuntimeSettings, crate::time::TimePresenter)> for RuntimeSettingsView
|
||||
provider_request_profiles,
|
||||
model_mappings: wire_model_mappings(settings.model_mappings),
|
||||
smart_scheduling_defaults: gateway_core::account::SmartSchedulingConfig::default(),
|
||||
quota_reset_window_weights_defaults: gateway_core::account::ResetWindowWeights::default(
|
||||
),
|
||||
rotation_strategy: settings.rotation_strategy.as_str().to_owned(),
|
||||
updated_at_display: time.datetime(&settings.updated_at),
|
||||
updated_at: settings.updated_at,
|
||||
@@ -765,6 +769,7 @@ impl RuntimeSettingsFields {
|
||||
openai_session_affinity_ttl_hours: self.openai_session_affinity_ttl_hours,
|
||||
responses_max_decompressed_body_bytes: self.responses_max_decompressed_body_bytes,
|
||||
smart_scheduling: self.smart_scheduling,
|
||||
quota_reset_window_weights: self.quota_reset_window_weights,
|
||||
min_codex_desktop_version: self.min_codex_desktop_version,
|
||||
min_codex_cli_version: self.min_codex_cli_version,
|
||||
usage_retention_days: u32::try_from(self.usage_retention_days)
|
||||
@@ -808,6 +813,7 @@ impl From<gateway_admin::model::settings::RuntimeSettingsValues> for RuntimeSett
|
||||
openai_session_affinity_ttl_hours: settings.openai_session_affinity_ttl_hours,
|
||||
responses_max_decompressed_body_bytes: settings.responses_max_decompressed_body_bytes,
|
||||
smart_scheduling: settings.smart_scheduling,
|
||||
quota_reset_window_weights: settings.quota_reset_window_weights,
|
||||
min_codex_desktop_version: settings.min_codex_desktop_version,
|
||||
min_codex_cli_version: settings.min_codex_cli_version,
|
||||
usage_retention_days: u64::from(settings.usage_retention_days),
|
||||
|
||||
@@ -664,6 +664,7 @@ impl SettingsStore for MemorySettingsStore {
|
||||
.values
|
||||
.responses_max_decompressed_body_bytes,
|
||||
smart_scheduling: command.values.smart_scheduling,
|
||||
quota_reset_window_weights: command.values.quota_reset_window_weights,
|
||||
min_codex_desktop_version: command.values.min_codex_desktop_version,
|
||||
min_codex_cli_version: command.values.min_codex_cli_version,
|
||||
usage_retention_days: command.values.usage_retention_days,
|
||||
@@ -1940,6 +1941,7 @@ fn test_runtime_settings() -> RuntimeSettings {
|
||||
openai_session_affinity_ttl_hours: 24,
|
||||
responses_max_decompressed_body_bytes: 64 * 1024 * 1024,
|
||||
smart_scheduling: gateway_core::account::SmartSchedulingConfig::default(),
|
||||
quota_reset_window_weights: gateway_core::account::ResetWindowWeights::default(),
|
||||
min_codex_desktop_version: None,
|
||||
min_codex_cli_version: None,
|
||||
usage_retention_days: 31,
|
||||
|
||||
@@ -63,6 +63,7 @@ fn update_body() -> Value {
|
||||
"responsesMaxDecompressedBodyBytes": 67108864,
|
||||
"rotationStrategy": "round_robin",
|
||||
"smartScheduling": gateway_core::account::SmartSchedulingConfig::default(),
|
||||
"quotaResetWindowWeights": gateway_core::account::ResetWindowWeights::default(),
|
||||
"minCodexDesktopVersion": "26.825.6671",
|
||||
"minCodexCliVersion": "0.40.0",
|
||||
"usageRetentionDays": 31,
|
||||
@@ -264,12 +265,14 @@ fn error_protection_requires_an_explicit_policy_in_settings_replacement() {
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn smart_settings_round_trip_and_invalid_updates_leave_the_saved_value_intact() {
|
||||
async fn scheduling_settings_round_trip_and_invalid_updates_leave_the_saved_value_intact() {
|
||||
let fixture = AdminTestFixture::new().await;
|
||||
fixture.auth.insert_session("valid-session");
|
||||
let mut body = update_body();
|
||||
let custom = json!({"loadWeight": 2.0, "quotaWeight": 0.0, "healthWeight": 1.0, "latencyWeight": 0.5, "resetWeight": 1.2, "queueWeight": 2.3, "resetWindowWeights":{"fiveHour":0.0,"weekly":1.5,"monthly":0.0}});
|
||||
body["smartScheduling"] = custom.clone();
|
||||
let windows = json!({"fiveHour":2.5,"weekly":0.0,"monthly":1.0});
|
||||
body["quotaResetWindowWeights"] = windows.clone();
|
||||
let response = app(fixture.state())
|
||||
.oneshot(request(
|
||||
Method::POST,
|
||||
@@ -281,6 +284,7 @@ async fn smart_settings_round_trip_and_invalid_updates_leave_the_saved_value_int
|
||||
assert_eq!(response.status(), StatusCode::OK);
|
||||
let response = response_json(response).await;
|
||||
assert_eq!(response["data"]["smartScheduling"], custom);
|
||||
assert_eq!(response["data"]["quotaResetWindowWeights"], windows);
|
||||
assert_eq!(
|
||||
response["data"]["smartSchedulingDefaults"],
|
||||
json!(gateway_core::account::SmartSchedulingConfig::default())
|
||||
@@ -301,7 +305,7 @@ async fn smart_settings_round_trip_and_invalid_updates_leave_the_saved_value_int
|
||||
missing.as_object_mut().unwrap().remove(field);
|
||||
invalid_values.push(missing);
|
||||
}
|
||||
for windows in [
|
||||
let invalid_windows = [
|
||||
json!({}),
|
||||
json!({"weekly":1}),
|
||||
json!(null),
|
||||
@@ -309,41 +313,53 @@ async fn smart_settings_round_trip_and_invalid_updates_leave_the_saved_value_int
|
||||
json!({"fiveHour":-1,"weekly":1,"monthly":0}),
|
||||
json!({"fiveHour":0,"weekly":1,"monthly":10.1}),
|
||||
json!({"fiveHour":0,"weekly":1,"monthly":0,"daily":1}),
|
||||
] {
|
||||
];
|
||||
for windows in &invalid_windows {
|
||||
let mut invalid = custom.clone();
|
||||
invalid["resetWindowWeights"] = windows;
|
||||
invalid["resetWindowWeights"] = windows.clone();
|
||||
invalid_values.push(invalid);
|
||||
}
|
||||
for invalid in invalid_values {
|
||||
body["smartScheduling"] = invalid;
|
||||
for (field, invalid) in invalid_values
|
||||
.into_iter()
|
||||
.map(|value| ("smartScheduling", value))
|
||||
.chain(
|
||||
invalid_windows
|
||||
.into_iter()
|
||||
.map(|value| ("quotaResetWindowWeights", value)),
|
||||
)
|
||||
{
|
||||
let mut invalid_body = body.clone();
|
||||
invalid_body[field] = invalid;
|
||||
let response = app(fixture.state())
|
||||
.oneshot(request(
|
||||
Method::POST,
|
||||
"/api/admin/settings/update",
|
||||
Some(body.clone()),
|
||||
Some(invalid_body),
|
||||
))
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(response.status(), StatusCode::UNPROCESSABLE_ENTITY);
|
||||
}
|
||||
for field in ["smartScheduling", "quotaResetWindowWeights"] {
|
||||
let mut missing = body.clone();
|
||||
missing.as_object_mut().unwrap().remove(field);
|
||||
let response = app(fixture.state())
|
||||
.oneshot(request(
|
||||
Method::POST,
|
||||
"/api/admin/settings/update",
|
||||
Some(missing),
|
||||
))
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(response.status(), StatusCode::UNPROCESSABLE_ENTITY);
|
||||
}
|
||||
body.as_object_mut().unwrap().remove("smartScheduling");
|
||||
let response = app(fixture.state())
|
||||
.oneshot(request(
|
||||
Method::POST,
|
||||
"/api/admin/settings/update",
|
||||
Some(body),
|
||||
))
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(response.status(), StatusCode::UNPROCESSABLE_ENTITY);
|
||||
let response = app(fixture.state())
|
||||
.oneshot(request(Method::GET, "/api/admin/settings", None))
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
response_json(response).await["data"]["smartScheduling"],
|
||||
custom
|
||||
);
|
||||
let saved = response_json(response).await;
|
||||
assert_eq!(saved["data"]["smartScheduling"], custom);
|
||||
assert_eq!(saved["data"]["quotaResetWindowWeights"], windows);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -357,11 +373,11 @@ fn settings_request_should_reject_unknown_rotation_strategy() {
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn short_request_retention_round_trips_and_invalid_days_do_not_replace_it() {
|
||||
async fn request_retention_round_trips_and_invalid_days_do_not_replace_it() {
|
||||
let fixture = AdminTestFixture::new().await;
|
||||
fixture.auth.insert_session("valid-session");
|
||||
let mut body = update_body();
|
||||
for days in [1, 3, 7, 15, 30, 31] {
|
||||
for days in [1, 31, 32, 365, 3650, u32::MAX] {
|
||||
body["usageRetentionDays"] = json!(days);
|
||||
let response = app(fixture.state())
|
||||
.oneshot(request(
|
||||
@@ -378,8 +394,7 @@ async fn short_request_retention_round_trips_and_invalid_days_do_not_replace_it(
|
||||
}
|
||||
for (days, expected_status) in [
|
||||
(json!(0), StatusCode::BAD_REQUEST),
|
||||
(json!(32), StatusCode::BAD_REQUEST),
|
||||
(json!(u32::MAX), StatusCode::BAD_REQUEST),
|
||||
(json!(u64::from(u32::MAX) + 1), StatusCode::BAD_REQUEST),
|
||||
(json!(-1), StatusCode::UNPROCESSABLE_ENTITY),
|
||||
(json!(1.5), StatusCode::UNPROCESSABLE_ENTITY),
|
||||
(json!(null), StatusCode::UNPROCESSABLE_ENTITY),
|
||||
@@ -402,7 +417,7 @@ async fn short_request_retention_round_trips_and_invalid_days_do_not_replace_it(
|
||||
assert_eq!(response.status(), StatusCode::OK);
|
||||
assert_eq!(
|
||||
response_json(response).await["data"]["usageRetentionDays"],
|
||||
31
|
||||
u32::MAX
|
||||
);
|
||||
}
|
||||
|
||||
@@ -423,7 +438,12 @@ fn settings_request_validates_cron_and_allows_disabled_empty_schedule() {
|
||||
(false, "08:00", false),
|
||||
(true, "0 8 * * MON-FRI", true),
|
||||
(true, "60 8 * * *", false),
|
||||
(true, "0 8 * * *;30 13 * * *", true),
|
||||
(true, "0 8 * * *\n30 13 * * *", false),
|
||||
(true, "0 8 * * *;60 13 * * *", false),
|
||||
(false, "0 8 * * *;", false),
|
||||
(true, "0 8 * * *;;30 13 * * *", false),
|
||||
(true, "0 8 * * *\r\n30 13 * * *", false),
|
||||
] {
|
||||
let mut body = update_body();
|
||||
body["accountWarmupEnabled"] = json!(enabled);
|
||||
@@ -436,6 +456,11 @@ fn settings_request_validates_cron_and_allows_disabled_empty_schedule() {
|
||||
assert_eq!(error.field(), "accountWarmupCron");
|
||||
}
|
||||
}
|
||||
let mut oversized = update_body();
|
||||
oversized["accountWarmupCron"] = json!(["* * * * *"; 26].join(";"));
|
||||
let request: UpdateRuntimeSettingsRequest = serde_json::from_value(oversized).unwrap();
|
||||
assert_eq!(request.validate().unwrap_err().field(), "accountWarmupCron");
|
||||
|
||||
let mut legacy = update_body();
|
||||
legacy.as_object_mut().unwrap().remove("accountWarmupCron");
|
||||
legacy["accountWarmupScheduleTime"] = json!("08:00");
|
||||
|
||||
@@ -4,6 +4,7 @@ use axum::{
|
||||
body::{Body, to_bytes},
|
||||
http::{Request, StatusCode},
|
||||
};
|
||||
use base64::{Engine as _, engine::general_purpose::STANDARD};
|
||||
use bytes::Bytes;
|
||||
use futures::{StreamExt as _, future::BoxFuture};
|
||||
use gateway_core::{
|
||||
@@ -122,10 +123,12 @@ async fn native_json_preserves_extensions_and_uses_client_key_authentication() {
|
||||
)]);
|
||||
let trace = session.trace.clone();
|
||||
let (router, execution) = fixture(session).await;
|
||||
let response = router
|
||||
.oneshot(request("/v1/messages", false))
|
||||
.await
|
||||
.unwrap();
|
||||
let mut incoming = request("/v1/messages", false);
|
||||
incoming.headers_mut().insert(
|
||||
"x-claude-code-session-id",
|
||||
"claude-session".parse().unwrap(),
|
||||
);
|
||||
let response = router.oneshot(incoming).await.unwrap();
|
||||
assert_eq!(response.status(), StatusCode::OK);
|
||||
let bytes = to_bytes(response.into_body(), usize::MAX).await.unwrap();
|
||||
assert_eq!(bytes, raw);
|
||||
@@ -136,6 +139,15 @@ async fn native_json_preserves_extensions_and_uses_client_key_authentication() {
|
||||
panic!("generate")
|
||||
};
|
||||
assert_eq!(generation.protocol_payload().protocol(), "anthropic");
|
||||
assert!(
|
||||
generation.protocol_payload().context()["opaque_request_headers"]
|
||||
.as_array()
|
||||
.unwrap()
|
||||
.contains(&json!([
|
||||
"x-claude-code-session-id",
|
||||
STANDARD.encode("claude-session")
|
||||
]))
|
||||
);
|
||||
assert_eq!(
|
||||
generation.protocol_payload().body()["future_extension"]["preserved"],
|
||||
true
|
||||
|
||||
@@ -17,17 +17,19 @@ mod quota_limits;
|
||||
pub use quota_limits::{AccountQuotaLimits, QuotaMergeBase, QuotaPauseDecision};
|
||||
mod proxy;
|
||||
pub use proxy::{InvalidOutboundProxy, OutboundProxy};
|
||||
mod scheduling;
|
||||
pub mod scope;
|
||||
mod selection;
|
||||
mod smart_scheduling;
|
||||
mod store;
|
||||
mod upstream;
|
||||
|
||||
pub use error::CredentialError;
|
||||
pub use model::*;
|
||||
pub use scheduling::{
|
||||
QuotaResetPeriod, ResetWindowWeights, SchedulingConfigError, SmartSchedulingConfig,
|
||||
};
|
||||
pub(crate) use selection::smart_score;
|
||||
pub use selection::*;
|
||||
pub use smart_scheduling::{QuotaResetPeriod, SmartSchedulingConfig, SmartSchedulingConfigError};
|
||||
pub use store::{
|
||||
AccountCatalogObservation, AccountCatalogOmissions, ProviderAccountStore, StoredAccountCatalog,
|
||||
};
|
||||
|
||||
+88
-44
@@ -1,4 +1,4 @@
|
||||
//! 智能调度参数;固定十分位保证快照可精确比较,浮点数只用于 wire 与评分
|
||||
//! 账号调度参数与共享重置窗口评分;固定十分位保证快照可精确比较,浮点数只用于 wire 与评分
|
||||
|
||||
use std::time::SystemTime;
|
||||
|
||||
@@ -9,7 +9,7 @@ use serde::{Deserialize, Serialize};
|
||||
#[serde(into = "SmartSchedulingValues")]
|
||||
pub struct SmartSchedulingConfig {
|
||||
weights: [u8; 6],
|
||||
reset_windows: [u8; 3],
|
||||
reset_windows: ResetWindowWeights,
|
||||
}
|
||||
|
||||
/// 账号通用额度的周期;Provider 按上游周期事实投影,不依赖窗口名称和槽位
|
||||
@@ -30,9 +30,9 @@ impl QuotaResetPeriod {
|
||||
}
|
||||
}
|
||||
|
||||
fn weight_tenths(value: f64, field: &'static str) -> Result<u8, SmartSchedulingConfigError> {
|
||||
fn weight_tenths(value: f64, field: &'static str) -> Result<u8, SchedulingConfigError> {
|
||||
if !(0.0..=10.0).contains(&value) || (value * 10.0).round() / 10.0 != value {
|
||||
return Err(SmartSchedulingConfigError::InvalidWeight(field));
|
||||
return Err(SchedulingConfigError::InvalidWeight(field));
|
||||
}
|
||||
Ok((value * 10.0).round() as u8)
|
||||
}
|
||||
@@ -52,13 +52,13 @@ impl Default for SmartSchedulingConfig {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
weights: [10, 8, 10, 5, 0, 0],
|
||||
reset_windows: [0; 3],
|
||||
reset_windows: ResetWindowWeights::default(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, thiserror::Error)]
|
||||
pub enum SmartSchedulingConfigError {
|
||||
pub enum SchedulingConfigError {
|
||||
#[error("{0} must be between 0 and 10 with at most one decimal place")]
|
||||
InvalidWeight(&'static str),
|
||||
#[error("at least one smart scheduling weight must be positive")]
|
||||
@@ -67,7 +67,7 @@ pub enum SmartSchedulingConfigError {
|
||||
|
||||
impl SmartSchedulingConfig {
|
||||
/// 顺序为负载、剩余额度、健康、首输出延迟、额度重置和排队压力
|
||||
pub fn new(weights: [f64; 6]) -> Result<Self, SmartSchedulingConfigError> {
|
||||
pub fn new(weights: [f64; 6]) -> Result<Self, SchedulingConfigError> {
|
||||
let mut tenths = [0; 6];
|
||||
for (index, field) in [
|
||||
"loadWeight",
|
||||
@@ -83,7 +83,7 @@ impl SmartSchedulingConfig {
|
||||
tenths[index] = weight_tenths(weights[index], field)?;
|
||||
}
|
||||
if tenths == [0; 6] {
|
||||
return Err(SmartSchedulingConfigError::EmptyWeights);
|
||||
return Err(SchedulingConfigError::EmptyWeights);
|
||||
}
|
||||
Ok(Self {
|
||||
weights: tenths,
|
||||
@@ -97,35 +97,14 @@ impl SmartSchedulingConfig {
|
||||
}
|
||||
|
||||
fn reset_enabled(self) -> bool {
|
||||
self.weights[4] > 0 && self.reset_windows != [0; 3]
|
||||
self.weights[4] > 0 && self.reset_windows.enabled()
|
||||
}
|
||||
|
||||
pub(crate) fn reset_score(self, signals: &AccountRuntimeSignals, now: SystemTime) -> f64 {
|
||||
if !self.reset_enabled() {
|
||||
return 0.0;
|
||||
}
|
||||
let mut scores = [0.0_f64; 3];
|
||||
for window in signals.quota_reset_windows.as_deref().unwrap_or_default() {
|
||||
let Ok(remaining) = window.reset_at.duration_since(now) else {
|
||||
continue;
|
||||
};
|
||||
if remaining.is_zero() {
|
||||
continue;
|
||||
}
|
||||
let half = f64::from(window.period.seconds()) / 7.0;
|
||||
let score = half / (half + remaining.as_secs_f64());
|
||||
// 同一周期只计最近的有效重置,避免重复额度桶叠加得分
|
||||
let slot = &mut scores[window.period as usize];
|
||||
*slot = slot.max(score);
|
||||
}
|
||||
// 缺失周期得零分,分母固定,避免少报窗口反而提高排名
|
||||
let weights = self.reset_windows.map(f64::from);
|
||||
scores
|
||||
.into_iter()
|
||||
.zip(weights)
|
||||
.map(|(score, w)| score * w)
|
||||
.sum::<f64>()
|
||||
/ weights.into_iter().sum::<f64>()
|
||||
self.reset_windows.score(signals, now)
|
||||
}
|
||||
|
||||
pub(crate) fn score_tolerance(self) -> f64 {
|
||||
@@ -157,14 +136,14 @@ struct SmartSchedulingValues {
|
||||
|
||||
#[derive(Default, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase", deny_unknown_fields)]
|
||||
struct ResetWindowWeights {
|
||||
struct ResetWindowValues {
|
||||
five_hour: f64,
|
||||
weekly: f64,
|
||||
monthly: f64,
|
||||
}
|
||||
|
||||
impl TryFrom<SmartSchedulingValues> for SmartSchedulingConfig {
|
||||
type Error = SmartSchedulingConfigError;
|
||||
type Error = SchedulingConfigError;
|
||||
|
||||
fn try_from(value: SmartSchedulingValues) -> Result<Self, Self::Error> {
|
||||
let mut config = Self::new([
|
||||
@@ -175,12 +154,7 @@ impl TryFrom<SmartSchedulingValues> for SmartSchedulingConfig {
|
||||
value.reset_weight,
|
||||
value.queue_weight,
|
||||
])?;
|
||||
let windows = value.reset_window_weights;
|
||||
config.reset_windows = [
|
||||
weight_tenths(windows.five_hour, "fiveHour")?,
|
||||
weight_tenths(windows.weekly, "weekly")?,
|
||||
weight_tenths(windows.monthly, "monthly")?,
|
||||
];
|
||||
config.reset_windows = value.reset_window_weights;
|
||||
Ok(config)
|
||||
}
|
||||
}
|
||||
@@ -202,11 +176,81 @@ impl From<SmartSchedulingConfig> for SmartSchedulingValues {
|
||||
latency_weight,
|
||||
reset_weight,
|
||||
queue_weight,
|
||||
reset_window_weights: ResetWindowWeights {
|
||||
five_hour: f64::from(value.reset_windows[0]) / 10.0,
|
||||
weekly: f64::from(value.reset_windows[1]) / 10.0,
|
||||
monthly: f64::from(value.reset_windows[2]) / 10.0,
|
||||
},
|
||||
reset_window_weights: value.reset_windows,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// 两种调度策略共用的重置窗口系数,各策略独立持有配置
|
||||
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize)]
|
||||
#[serde(into = "ResetWindowValues")]
|
||||
pub struct ResetWindowWeights {
|
||||
weights: [u8; 3],
|
||||
}
|
||||
|
||||
impl ResetWindowWeights {
|
||||
/// 顺序为 5 小时、周、月;全零表示未指定窗口
|
||||
pub fn new(weights: [f64; 3]) -> Result<Self, SchedulingConfigError> {
|
||||
Ok(Self {
|
||||
weights: [
|
||||
weight_tenths(weights[0], "fiveHour")?,
|
||||
weight_tenths(weights[1], "weekly")?,
|
||||
weight_tenths(weights[2], "monthly")?,
|
||||
],
|
||||
})
|
||||
}
|
||||
|
||||
pub(crate) fn enabled(self) -> bool {
|
||||
self.weights != [0; 3]
|
||||
}
|
||||
|
||||
pub(crate) fn score(self, signals: &AccountRuntimeSignals, now: SystemTime) -> f64 {
|
||||
if !self.enabled() {
|
||||
return 0.0;
|
||||
}
|
||||
let mut scores = [0.0_f64; 3];
|
||||
for window in signals.quota_reset_windows.as_deref().unwrap_or_default() {
|
||||
let Ok(remaining) = window.reset_at.duration_since(now) else {
|
||||
continue;
|
||||
};
|
||||
if remaining.is_zero() {
|
||||
continue;
|
||||
}
|
||||
let half = f64::from(window.period.seconds()) / 7.0;
|
||||
let score = half / (half + remaining.as_secs_f64());
|
||||
// 同一周期只计最近的有效重置,避免重复额度桶叠加得分
|
||||
let slot = &mut scores[window.period as usize];
|
||||
*slot = slot.max(score);
|
||||
}
|
||||
// 缺失周期得零分,分母固定,避免少报窗口反而提高排名
|
||||
let weights = self.weights.map(f64::from);
|
||||
scores
|
||||
.into_iter()
|
||||
.zip(weights)
|
||||
.map(|(score, w)| score * w)
|
||||
.sum::<f64>()
|
||||
/ weights.into_iter().sum::<f64>()
|
||||
}
|
||||
}
|
||||
|
||||
impl<'de> Deserialize<'de> for ResetWindowWeights {
|
||||
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
|
||||
// 与智能调度一致,先恢复 flatten 缓冲的小数再校验
|
||||
let value = serde_json::Value::deserialize(deserializer)?;
|
||||
let values =
|
||||
serde_json::from_value::<ResetWindowValues>(value).map_err(serde::de::Error::custom)?;
|
||||
Self::new([values.five_hour, values.weekly, values.monthly])
|
||||
.map_err(serde::de::Error::custom)
|
||||
}
|
||||
}
|
||||
|
||||
impl From<ResetWindowWeights> for ResetWindowValues {
|
||||
fn from(value: ResetWindowWeights) -> Self {
|
||||
let [five_hour, weekly, monthly] = value.weights.map(|weight| f64::from(weight) / 10.0);
|
||||
Self {
|
||||
five_hour,
|
||||
weekly,
|
||||
monthly,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -12,7 +12,8 @@ use crate::concurrency::{CapacityWait, ConcurrencyQueuePolicy, QueueRejection};
|
||||
use crate::identity::ProviderKind;
|
||||
|
||||
use super::{
|
||||
AccountConcurrency, AccountStatus, ProviderAccount, ProviderAccountId, SmartSchedulingConfig,
|
||||
AccountConcurrency, AccountStatus, ProviderAccount, ProviderAccountId, ResetWindowWeights,
|
||||
SmartSchedulingConfig,
|
||||
};
|
||||
|
||||
/// `runtime_settings.rotation_strategy` 的稳定值
|
||||
@@ -90,6 +91,7 @@ impl AccountAffinity {
|
||||
pub struct AccountSelectionPolicy {
|
||||
strategy: RotationStrategy,
|
||||
smart_scheduling: SmartSchedulingConfig,
|
||||
quota_reset_window_weights: ResetWindowWeights,
|
||||
max_concurrent_per_account: AccountConcurrency,
|
||||
queue_policy: ConcurrencyQueuePolicy,
|
||||
openai_guardian_reserved_concurrency: u32,
|
||||
@@ -108,6 +110,7 @@ impl AccountSelectionPolicy {
|
||||
Self {
|
||||
strategy,
|
||||
smart_scheduling: SmartSchedulingConfig::default(),
|
||||
quota_reset_window_weights: ResetWindowWeights::default(),
|
||||
max_concurrent_per_account: max_concurrent_per_account.into(),
|
||||
openai_guardian_reserved_concurrency: 0,
|
||||
openai_account_affinity: AccountAffinity::default(),
|
||||
@@ -121,6 +124,17 @@ impl AccountSelectionPolicy {
|
||||
}
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub const fn with_quota_reset_window_weights(mut self, weights: ResetWindowWeights) -> Self {
|
||||
self.quota_reset_window_weights = weights;
|
||||
self
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub const fn quota_reset_window_weights(self) -> ResetWindowWeights {
|
||||
self.quota_reset_window_weights
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub const fn with_openai_account_affinity(mut self, affinity: AccountAffinity) -> Self {
|
||||
self.openai_account_affinity = affinity;
|
||||
@@ -799,24 +813,31 @@ impl AccountSelector {
|
||||
let candidate = match context.policy.strategy() {
|
||||
RotationStrategy::QuotaResetPriority => {
|
||||
eligible.sort_by(|left, right| {
|
||||
(
|
||||
left.signals.quota_reset_at.is_none(),
|
||||
left.signals.quota_reset_at,
|
||||
)
|
||||
.cmp(&(
|
||||
right.signals.quota_reset_at.is_none(),
|
||||
right.signals.quota_reset_at,
|
||||
))
|
||||
.then_with(|| {
|
||||
capacity_utilization(left, context)
|
||||
.total_cmp(&capacity_utilization(right, context))
|
||||
})
|
||||
.then_with(|| {
|
||||
left.signals
|
||||
.last_started_at
|
||||
.cmp(&right.signals.last_started_at)
|
||||
})
|
||||
.then_with(|| left.account.id().cmp(right.account.id()))
|
||||
let windows = context.policy.quota_reset_window_weights();
|
||||
if windows.enabled() {
|
||||
windows
|
||||
.score(&right.signals, context.now)
|
||||
.total_cmp(&windows.score(&left.signals, context.now))
|
||||
} else {
|
||||
(
|
||||
left.signals.quota_reset_at.is_none(),
|
||||
left.signals.quota_reset_at,
|
||||
)
|
||||
.cmp(&(
|
||||
right.signals.quota_reset_at.is_none(),
|
||||
right.signals.quota_reset_at,
|
||||
))
|
||||
}
|
||||
.then_with(|| {
|
||||
capacity_utilization(left, context)
|
||||
.total_cmp(&capacity_utilization(right, context))
|
||||
})
|
||||
.then_with(|| {
|
||||
left.signals
|
||||
.last_started_at
|
||||
.cmp(&right.signals.last_started_at)
|
||||
})
|
||||
.then_with(|| left.account.id().cmp(right.account.id()))
|
||||
});
|
||||
eligible.first().copied()?
|
||||
}
|
||||
|
||||
@@ -28,11 +28,10 @@ pub struct StoredAccountCatalog {
|
||||
pub document: bytes::Bytes,
|
||||
}
|
||||
|
||||
/// 批量选号的存储优化:只有账号自己的当前版本、有效时间和目录摘要都匹配才可跳过
|
||||
/// 批量选号只按账号当前凭据和套餐的目录摘要排除候选
|
||||
pub struct AccountCatalogOmissions {
|
||||
pub documents: Vec<[u8; 32]>,
|
||||
pub exceptions: Vec<ProviderAccountId>,
|
||||
pub observed_after: std::time::SystemTime,
|
||||
pub as_of: std::time::SystemTime,
|
||||
}
|
||||
|
||||
|
||||
@@ -5,6 +5,14 @@ use crate::{account::OpaqueProviderData, identity::ProviderKind, routing::Config
|
||||
use futures::future::BoxFuture;
|
||||
|
||||
pub trait ProviderRuntimePolicyPort: Send + Sync {
|
||||
/// 后台模型操作读取 Provider 全局画像,不读取单个 Client Key 的覆盖
|
||||
fn load_request_profile<'a>(
|
||||
&'a self,
|
||||
_provider: &'a ProviderKind,
|
||||
) -> BoxFuture<'a, Result<Option<OpaqueProviderData>, ProviderStoreError>> {
|
||||
Box::pin(async { Ok(None) })
|
||||
}
|
||||
|
||||
/// 原子推进预热执行游标,重启或时钟回拨后不重复领取已消费的时刻
|
||||
fn claim_warmup_slot<'a>(
|
||||
&'a self,
|
||||
@@ -52,7 +60,7 @@ pub trait ProviderRuntimePolicyPort: Send + Sync {
|
||||
}
|
||||
}
|
||||
|
||||
/// 校验五段 Cron 预热计划
|
||||
/// 校验单条五段 Cron 表达式
|
||||
#[must_use]
|
||||
pub fn valid_warmup_cron(value: &str) -> bool {
|
||||
parse_warmup_cron(value).is_some()
|
||||
@@ -73,7 +81,7 @@ fn parse_warmup_cron(value: &str) -> Option<cron::Schedule> {
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub struct ProviderWarmupPolicy {
|
||||
enabled: bool,
|
||||
cron: String,
|
||||
schedules: Vec<cron::Schedule>,
|
||||
model: Option<String>,
|
||||
}
|
||||
|
||||
@@ -84,29 +92,47 @@ impl ProviderWarmupPolicy {
|
||||
cron: &str,
|
||||
model: Option<&str>,
|
||||
) -> Result<(), &'static str> {
|
||||
if (enabled || !cron.is_empty()) && !valid_warmup_cron(cron) {
|
||||
Self::validate_and_parse(enabled, cron, model).map(|_| ())
|
||||
}
|
||||
|
||||
fn validate_and_parse(
|
||||
enabled: bool,
|
||||
cron: &str,
|
||||
model: Option<&str>,
|
||||
) -> Result<Vec<cron::Schedule>, &'static str> {
|
||||
if cron.len() > 255 || (enabled && cron.is_empty()) {
|
||||
return Err("account_warmup_cron");
|
||||
}
|
||||
// 分号分隔独立表达式,逗号保留给 Cron 字段内的列表
|
||||
let schedules = if cron.is_empty() {
|
||||
Vec::new()
|
||||
} else {
|
||||
cron.split(';')
|
||||
.map(parse_warmup_cron)
|
||||
.collect::<Option<Vec<_>>>()
|
||||
.ok_or("account_warmup_cron")?
|
||||
};
|
||||
if (enabled && model.is_none()) || !valid_optional_probe_model(model) {
|
||||
return Err("account_warmup_model");
|
||||
}
|
||||
Ok(())
|
||||
Ok(schedules)
|
||||
}
|
||||
|
||||
pub fn try_new(
|
||||
enabled: bool,
|
||||
cron: String,
|
||||
cron: &str,
|
||||
model: Option<String>,
|
||||
) -> Result<Self, ProviderStoreError> {
|
||||
if Self::validate_values(enabled, &cron, model.as_deref()).is_err() {
|
||||
return Err(ProviderStoreError::new(
|
||||
ProviderStoreErrorKind::InvalidData,
|
||||
"validate warmup policy",
|
||||
));
|
||||
}
|
||||
let schedules =
|
||||
Self::validate_and_parse(enabled, cron, model.as_deref()).map_err(|_| {
|
||||
ProviderStoreError::new(
|
||||
ProviderStoreErrorKind::InvalidData,
|
||||
"validate warmup policy",
|
||||
)
|
||||
})?;
|
||||
Ok(Self {
|
||||
enabled,
|
||||
cron,
|
||||
schedules,
|
||||
model,
|
||||
})
|
||||
}
|
||||
@@ -115,7 +141,7 @@ impl ProviderWarmupPolicy {
|
||||
pub const fn disabled() -> Self {
|
||||
Self {
|
||||
enabled: false,
|
||||
cron: String::new(),
|
||||
schedules: Vec::new(),
|
||||
model: None,
|
||||
}
|
||||
}
|
||||
@@ -125,11 +151,6 @@ impl ProviderWarmupPolicy {
|
||||
self.enabled
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn cron(&self) -> &str {
|
||||
&self.cron
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn model(&self) -> Option<&str> {
|
||||
self.model.as_deref()
|
||||
@@ -138,7 +159,10 @@ impl ProviderWarmupPolicy {
|
||||
/// 匹配部署时区中的整分钟时刻,时区重叠及执行去重由 Worker 与存储端口负责
|
||||
#[must_use]
|
||||
pub fn matches_slot(&self, slot: chrono::NaiveDateTime) -> bool {
|
||||
parse_warmup_cron(&self.cron).is_some_and(|schedule| schedule.includes(slot.and_utc()))
|
||||
let instant = slot.and_utc();
|
||||
self.schedules
|
||||
.iter()
|
||||
.any(|schedule| schedule.includes(instant))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1247,13 +1247,13 @@ impl RuntimeSnapshot {
|
||||
operation: &Operation,
|
||||
context: &RoutingContext,
|
||||
) -> Result<RoutingPlan, RoutingError> {
|
||||
self.plan_inner(
|
||||
public_model,
|
||||
operation,
|
||||
self.all_account_scope(),
|
||||
context,
|
||||
false,
|
||||
)
|
||||
// 探测没有 Client Key,沿用同一发布快照的全局画像
|
||||
let scope = self
|
||||
.all_account_scope()
|
||||
.as_ref()
|
||||
.clone()
|
||||
.with_request_profiles(self.settings().request_profiles().clone());
|
||||
self.plan_inner(public_model, operation, Arc::new(scope), context, false)
|
||||
}
|
||||
|
||||
fn plan_inner(
|
||||
|
||||
@@ -101,6 +101,7 @@ impl CompiledSettings {
|
||||
u64::from(settings.openai_session_affinity_ttl_hours) * 3600,
|
||||
))
|
||||
.with_smart_scheduling(settings.smart_scheduling)
|
||||
.with_quota_reset_window_weights(settings.quota_reset_window_weights)
|
||||
.with_queue(ConcurrencyQueuePolicy {
|
||||
max_waiting: settings.max_waiting_per_account,
|
||||
timeout: Duration::from_secs(u64::from(settings.account_queue_timeout_seconds)),
|
||||
|
||||
@@ -30,6 +30,8 @@ pub struct SettingsValues {
|
||||
pub(crate) openai_session_affinity_ttl_hours: u32,
|
||||
pub(crate) responses_max_decompressed_body_bytes: u64,
|
||||
pub(crate) smart_scheduling: crate::account::SmartSchedulingConfig,
|
||||
#[serde(default)]
|
||||
pub(crate) quota_reset_window_weights: crate::account::ResetWindowWeights,
|
||||
pub(crate) rotation_strategy: String,
|
||||
pub(crate) model_mappings: Arc<BTreeMap<String, String>>,
|
||||
pub(crate) min_codex_desktop_version: Option<String>,
|
||||
@@ -111,6 +113,15 @@ impl SettingsValues {
|
||||
&self.request_profiles
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub const fn with_quota_reset_window_weights(
|
||||
mut self,
|
||||
weights: crate::account::ResetWindowWeights,
|
||||
) -> Self {
|
||||
self.quota_reset_window_weights = weights;
|
||||
self
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub const fn with_smart_scheduling(
|
||||
mut self,
|
||||
@@ -201,6 +212,7 @@ impl SettingsValues {
|
||||
openai_session_affinity_ttl_hours: 24,
|
||||
responses_max_decompressed_body_bytes: 64 * 1024 * 1024,
|
||||
smart_scheduling: crate::account::SmartSchedulingConfig::default(),
|
||||
quota_reset_window_weights: crate::account::ResetWindowWeights::default(),
|
||||
rotation_strategy: rotation_strategy.into(),
|
||||
model_mappings: Arc::new(model_mappings),
|
||||
min_codex_desktop_version,
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
mod location;
|
||||
mod model_access;
|
||||
mod proxy;
|
||||
mod quota_reset_priority;
|
||||
mod scope;
|
||||
mod selection;
|
||||
mod selection_diagnostics;
|
||||
|
||||
@@ -0,0 +1,135 @@
|
||||
//! 验证重置窗口独立排序、相对系数及亲和与可用性边界
|
||||
|
||||
use std::time::Duration;
|
||||
|
||||
use gateway_core::account::{
|
||||
AccountQuotaResetWindow, AccountSelector, QuotaResetPeriod, ResetWindowWeights,
|
||||
RotationStrategy,
|
||||
};
|
||||
|
||||
use super::{candidate, context};
|
||||
|
||||
#[test]
|
||||
fn selected_windows_rank_strictly_without_mixing_runtime_scores_or_rotating_near_ties() {
|
||||
let mut context = context(RotationStrategy::QuotaResetPriority);
|
||||
let mut early_weekly = candidate("acct_early_weekly", 2, Some(100));
|
||||
early_weekly.signals.failure_rate_basis_points = Some(9_000);
|
||||
early_weekly.signals.first_output_latency_ms = Some(20_000);
|
||||
let mut late_weekly = candidate("acct_late_weekly", 0, Some(9_900));
|
||||
late_weekly.signals.failure_rate_basis_points = Some(0);
|
||||
late_weekly.signals.first_output_latency_ms = Some(10);
|
||||
for (candidate, short, weekly) in [
|
||||
(&mut early_weekly, 14_400, 6 * 86_400),
|
||||
(&mut late_weekly, 3_600, 6 * 86_400 + 43_200),
|
||||
] {
|
||||
candidate.signals.quota_reset_at = Some(context.now + Duration::from_secs(short));
|
||||
candidate.signals.quota_reset_windows = Some(
|
||||
[
|
||||
(QuotaResetPeriod::FiveHour, short),
|
||||
(QuotaResetPeriod::Weekly, weekly),
|
||||
]
|
||||
.map(|(period, seconds)| AccountQuotaResetWindow {
|
||||
period,
|
||||
reset_at: context.now + Duration::from_secs(seconds),
|
||||
})
|
||||
.into(),
|
||||
);
|
||||
}
|
||||
let mut candidates = [early_weekly, late_weekly];
|
||||
for (weights, expected) in [
|
||||
([0.0, 0.0, 0.0], "acct_late_weekly"),
|
||||
([1.0, 0.0, 0.0], "acct_late_weekly"),
|
||||
([0.0, 0.1, 0.0], "acct_early_weekly"),
|
||||
([0.0, 1.0, 0.0], "acct_early_weekly"),
|
||||
([0.0, 10.0, 0.0], "acct_early_weekly"),
|
||||
([1.0, 0.1, 0.0], "acct_late_weekly"),
|
||||
([10.0, 1.0, 0.0], "acct_late_weekly"),
|
||||
([0.1, 10.0, 0.0], "acct_early_weekly"),
|
||||
] {
|
||||
context.policy = context
|
||||
.policy
|
||||
.with_quota_reset_window_weights(ResetWindowWeights::new(weights).unwrap());
|
||||
for cursor in 0..6 {
|
||||
context.round_robin_cursor = cursor;
|
||||
assert_eq!(
|
||||
AccountSelector
|
||||
.select(&candidates, &context)
|
||||
.unwrap()
|
||||
.candidate()
|
||||
.account
|
||||
.id()
|
||||
.as_str(),
|
||||
expected,
|
||||
"weights {weights:?}, cursor {cursor}"
|
||||
);
|
||||
}
|
||||
}
|
||||
context.preferred_account = Some(candidates[1].account.id().clone());
|
||||
let selected = AccountSelector.select(&candidates, &context).unwrap();
|
||||
assert_eq!(
|
||||
selected.candidate().account.id().as_str(),
|
||||
"acct_late_weekly"
|
||||
);
|
||||
assert_eq!(
|
||||
selected.preferred(),
|
||||
gateway_core::account::PreferredAccountSelection::Hit
|
||||
);
|
||||
|
||||
context.preferred_account = None;
|
||||
candidates[0].signals.in_flight = 3;
|
||||
assert_eq!(
|
||||
AccountSelector
|
||||
.select(&candidates, &context)
|
||||
.unwrap()
|
||||
.candidate()
|
||||
.account
|
||||
.id()
|
||||
.as_str(),
|
||||
"acct_late_weekly"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn missing_or_elapsed_selected_windows_do_not_fall_back_to_disabled_periods() {
|
||||
let mut context = context(RotationStrategy::QuotaResetPriority);
|
||||
context.policy = context
|
||||
.policy
|
||||
.with_quota_reset_window_weights(ResetWindowWeights::new([0.0, 0.0, 1.0]).unwrap());
|
||||
let mut known = candidate("acct_known_monthly", 1, None);
|
||||
known.signals.quota_reset_windows = Some(
|
||||
vec![AccountQuotaResetWindow {
|
||||
period: QuotaResetPeriod::Monthly,
|
||||
reset_at: context.now + Duration::from_secs(30 * 86_400),
|
||||
}]
|
||||
.into(),
|
||||
);
|
||||
for reset_at in [
|
||||
None,
|
||||
Some(context.now),
|
||||
Some(context.now - Duration::from_secs(1)),
|
||||
] {
|
||||
let mut missing = candidate("acct_earlier_other_period", 0, None);
|
||||
missing.signals.quota_reset_at = Some(context.now + Duration::from_secs(1));
|
||||
missing.signals.quota_reset_windows = Some(
|
||||
reset_at
|
||||
.into_iter()
|
||||
.map(|reset_at| AccountQuotaResetWindow {
|
||||
period: QuotaResetPeriod::Monthly,
|
||||
reset_at,
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
.into(),
|
||||
);
|
||||
let candidates = [missing, known.clone()];
|
||||
assert_eq!(
|
||||
AccountSelector
|
||||
.select(&candidates, &context)
|
||||
.unwrap()
|
||||
.candidate()
|
||||
.account
|
||||
.id()
|
||||
.as_str(),
|
||||
"acct_known_monthly"
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -1228,6 +1228,7 @@ fn plan_with_protection(
|
||||
None,
|
||||
)
|
||||
.with_smart_scheduling(account_selection_policy.smart_scheduling())
|
||||
.with_quota_reset_window_weights(account_selection_policy.quota_reset_window_weights())
|
||||
.with_max_account_rotations(account_selection_policy.max_account_rotations())
|
||||
.with_openai_account_affinity(account_selection_policy.openai_account_affinity())
|
||||
.with_openai_session_affinity_ttl_hours(
|
||||
|
||||
@@ -3443,7 +3443,7 @@ fn provider_local_probe_failure_should_remain_distinct_from_upstream() {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn diagnostic_probe_does_not_apply_data_plane_account_model_policy() {
|
||||
fn diagnostic_probe_uses_global_profile_without_data_plane_account_model_policy() {
|
||||
let provider = ProviderKind::new("openai").expect("provider");
|
||||
let account_id = ProviderAccountId::new("acct_probe").expect("account");
|
||||
let snapshot = probe_snapshot().with_account_directory(Arc::new(RuntimeAccountDirectory::new(
|
||||
@@ -3458,10 +3458,21 @@ fn diagnostic_probe_does_not_apply_data_plane_account_model_policy() {
|
||||
),
|
||||
)]),
|
||||
)));
|
||||
let profile = gateway_core::account::OpaqueProviderData::new(
|
||||
json!({"identity":"global-probe"})
|
||||
.as_object()
|
||||
.unwrap()
|
||||
.clone(),
|
||||
);
|
||||
let settings = snapshot
|
||||
.settings()
|
||||
.clone()
|
||||
.with_request_profiles(BTreeMap::from([(provider.clone(), profile.clone())]));
|
||||
let snapshot = snapshot.with_settings(&settings).unwrap();
|
||||
let service = DefaultExecutionService::new(
|
||||
RuntimeSnapshotHandle::new(snapshot),
|
||||
Arc::new(TrackingExecutionStore::default()),
|
||||
ProviderRegistry::new([Arc::new(LocalFailingProvider) as Arc<dyn Provider>])
|
||||
ProviderRegistry::new([Arc::new(ProfileCheckingProvider(profile)) as Arc<dyn Provider>])
|
||||
.expect("providers"),
|
||||
Arc::new(UnusedAdmissions),
|
||||
Arc::new(UnusedContinuation),
|
||||
@@ -3862,6 +3873,36 @@ impl Provider for FailingProvider {
|
||||
|
||||
struct LocalFailingProvider;
|
||||
|
||||
struct ProfileCheckingProvider(gateway_core::account::OpaqueProviderData);
|
||||
|
||||
#[async_trait]
|
||||
impl Provider for ProfileCheckingProvider {
|
||||
fn name(&self) -> &'static str {
|
||||
"openai"
|
||||
}
|
||||
|
||||
fn catalog_generation(&self) -> ProviderCatalogGeneration {
|
||||
ProviderCatalogGeneration::default()
|
||||
}
|
||||
|
||||
async fn query_model_capabilities(
|
||||
&self,
|
||||
) -> Result<Vec<ProviderModelCapabilities>, ProviderError> {
|
||||
Ok(Vec::new())
|
||||
}
|
||||
|
||||
async fn execute(
|
||||
self: Arc<Self>,
|
||||
request: ProviderRequest,
|
||||
context: AttemptContext,
|
||||
) -> Result<ProviderStream, ProviderError> {
|
||||
assert_eq!(context.request_profile(), Some(&self.0));
|
||||
Arc::new(LocalFailingProvider)
|
||||
.execute(request, context)
|
||||
.await
|
||||
}
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
impl Provider for LocalFailingProvider {
|
||||
fn name(&self) -> &'static str {
|
||||
|
||||
@@ -252,14 +252,10 @@ fn warmup_cron_validation_and_calendar_matching() {
|
||||
] {
|
||||
assert!(!valid_warmup_cron(value), "{value:?}");
|
||||
}
|
||||
let policy = ProviderWarmupPolicy::try_new(
|
||||
true,
|
||||
"0 8,13 * * MON-FRI".to_owned(),
|
||||
Some("test-model".to_owned()),
|
||||
)
|
||||
.unwrap();
|
||||
let policy =
|
||||
ProviderWarmupPolicy::try_new(true, "0 8,13 * * MON-FRI", Some("test-model".to_owned()))
|
||||
.unwrap();
|
||||
assert!(policy.enabled());
|
||||
assert_eq!(policy.cron(), "0 8,13 * * MON-FRI");
|
||||
assert_eq!(policy.model(), Some("test-model"));
|
||||
for (day, hour, minute, expected) in [
|
||||
(9, 8, 0, true),
|
||||
@@ -275,19 +271,39 @@ fn warmup_cron_validation_and_calendar_matching() {
|
||||
.unwrap();
|
||||
assert_eq!(policy.matches_slot(slot), expected, "{slot}");
|
||||
}
|
||||
assert!(ProviderWarmupPolicy::try_new(false, String::new(), None).is_ok());
|
||||
assert!(
|
||||
ProviderWarmupPolicy::try_new(true, String::new(), Some("test-model".to_owned())).is_err()
|
||||
);
|
||||
assert!(ProviderWarmupPolicy::try_new(false, "08:00".to_owned(), None).is_err());
|
||||
assert!(ProviderWarmupPolicy::try_new(false, "", None).is_ok());
|
||||
assert!(ProviderWarmupPolicy::try_new(true, "", Some("test-model".to_owned())).is_err());
|
||||
assert!(ProviderWarmupPolicy::try_new(false, "08:00", None).is_err());
|
||||
assert!(!valid_warmup_cron(&format!("0{}8 * * *", " ".repeat(256))));
|
||||
let leap = ProviderWarmupPolicy::try_new(false, "0 0 29 FEB *".to_owned(), None).unwrap();
|
||||
let leap = ProviderWarmupPolicy::try_new(false, "0 0 29 FEB *", None).unwrap();
|
||||
let slot = NaiveDate::from_ymd_opt(2028, 2, 29)
|
||||
.unwrap()
|
||||
.and_hms_opt(0, 0, 0)
|
||||
.unwrap();
|
||||
assert!(leap.matches_slot(slot));
|
||||
assert!(!leap.matches_slot(slot + chrono::Duration::days(1)));
|
||||
assert!(ProviderWarmupPolicy::try_new(true, "invalid".to_owned(), None).is_err());
|
||||
assert!(ProviderWarmupPolicy::try_new(true, "0 8 * * *".to_owned(), None).is_err());
|
||||
assert!(ProviderWarmupPolicy::try_new(true, "invalid", None).is_err());
|
||||
assert!(ProviderWarmupPolicy::try_new(true, "0 8 * * *", None).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn warmup_matches_only_the_scheduled_hour_and_minute_pairs() {
|
||||
use chrono::NaiveDate;
|
||||
use gateway_core::provider_ports::ProviderWarmupPolicy;
|
||||
|
||||
let policy = ProviderWarmupPolicy::try_new(
|
||||
true,
|
||||
"58 5 * * *;59 10 * * *;0 16 * * *;1 21 * * *;0 16 * * MON-FRI",
|
||||
Some("test-model".to_owned()),
|
||||
)
|
||||
.unwrap();
|
||||
let date = NaiveDate::from_ymd_opt(2026, 11, 13).unwrap();
|
||||
for minute in 0..1440 {
|
||||
let slot = date.and_hms_opt(minute / 60, minute % 60, 0).unwrap();
|
||||
assert_eq!(
|
||||
policy.matches_slot(slot),
|
||||
[358, 659, 960, 1261].contains(&minute),
|
||||
"{slot}"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -877,11 +877,15 @@ fn compiler_accepts_unlimited_default_account_concurrency() {
|
||||
|
||||
#[test]
|
||||
fn compiled_plans_keep_their_scheduling_config_after_a_new_snapshot_is_built() {
|
||||
use gateway_core::account::SmartSchedulingConfig;
|
||||
use gateway_core::account::{ResetWindowWeights, SmartSchedulingConfig};
|
||||
let configs = [
|
||||
SmartSchedulingConfig::default(),
|
||||
SmartSchedulingConfig::new([0.0, 2.0, 1.0, 0.5, 1.2, 2.3]).unwrap(),
|
||||
];
|
||||
let windows = [
|
||||
ResetWindowWeights::default(),
|
||||
ResetWindowWeights::new([0.0, 1.5, 0.0]).unwrap(),
|
||||
];
|
||||
let mut plans = Vec::new();
|
||||
for (index, config) in configs.into_iter().enumerate() {
|
||||
let facts = SnapshotFacts::new(
|
||||
@@ -889,6 +893,7 @@ fn compiled_plans_keep_their_scheduling_config_after_a_new_snapshot_is_built() {
|
||||
revision(index as u64 + 1),
|
||||
SettingsValues::new(3, "smart", BTreeMap::new(), None, None)
|
||||
.with_smart_scheduling(config)
|
||||
.with_quota_reset_window_weights(windows[index])
|
||||
.with_openai_guardian_reserved_concurrency(index as u32),
|
||||
vec![],
|
||||
vec![],
|
||||
@@ -921,6 +926,10 @@ fn compiled_plans_keep_their_scheduling_config_after_a_new_snapshot_is_built() {
|
||||
index as u32
|
||||
);
|
||||
assert_eq!(plan.account_selection_policy().smart_scheduling(), config);
|
||||
assert_eq!(
|
||||
plan.account_selection_policy().quota_reset_window_weights(),
|
||||
windows[index]
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -154,6 +154,7 @@ pub struct RuntimeSettings {
|
||||
pub openai_session_affinity_ttl_hours: u32,
|
||||
pub responses_max_decompressed_body_bytes: u64,
|
||||
pub smart_scheduling: SmartSchedulingConfig,
|
||||
pub quota_reset_window_weights: ResetWindowWeights,
|
||||
pub min_codex_desktop_version: Option<String>,
|
||||
pub min_codex_cli_version: Option<String>,
|
||||
pub usage_retention_days: u32,
|
||||
@@ -194,6 +195,7 @@ pub struct ReplaceRuntimeSettings {
|
||||
pub openai_session_affinity_ttl_hours: u32,
|
||||
pub responses_max_decompressed_body_bytes: u64,
|
||||
pub smart_scheduling: SmartSchedulingConfig,
|
||||
pub quota_reset_window_weights: ResetWindowWeights,
|
||||
pub min_codex_desktop_version: Option<String>,
|
||||
pub min_codex_cli_version: Option<String>,
|
||||
pub usage_retention_days: u32,
|
||||
@@ -405,6 +407,7 @@ impl From<RuntimeSettings> for ReplaceRuntimeSettings {
|
||||
openai_session_affinity_ttl_hours: settings.openai_session_affinity_ttl_hours,
|
||||
responses_max_decompressed_body_bytes: settings.responses_max_decompressed_body_bytes,
|
||||
smart_scheduling: settings.smart_scheduling,
|
||||
quota_reset_window_weights: settings.quota_reset_window_weights,
|
||||
min_codex_desktop_version: settings.min_codex_desktop_version,
|
||||
min_codex_cli_version: settings.min_codex_cli_version,
|
||||
usage_retention_days: settings.usage_retention_days,
|
||||
|
||||
@@ -5,6 +5,7 @@ mod content;
|
||||
mod error;
|
||||
mod request;
|
||||
mod response;
|
||||
mod session;
|
||||
mod stream;
|
||||
mod thinking;
|
||||
mod tools;
|
||||
@@ -20,6 +21,7 @@ pub use request::{
|
||||
pub use response::{
|
||||
messages_to_responses_event, messages_to_responses_response, responses_to_messages_response,
|
||||
};
|
||||
pub use session::claude_session_id;
|
||||
pub use stream::{
|
||||
MessagesAccumulator, MessagesToResponsesStream, ResponsesToMessagesStream,
|
||||
message_to_stream_events,
|
||||
|
||||
@@ -0,0 +1,36 @@
|
||||
//! Claude Code 明确会话身份的请求头与 metadata 解析
|
||||
|
||||
use serde_json::{Map, Value};
|
||||
|
||||
/// 优先使用 Claude Code 会话头,再读取新旧 metadata.user_id 中的会话标识
|
||||
///
|
||||
/// 普通用户标识与对话内容不作为会话身份
|
||||
#[must_use]
|
||||
pub fn claude_session_id(body: &Map<String, Value>, header: Option<&str>) -> Option<String> {
|
||||
if let Some(session) = header.and_then(valid_session_id) {
|
||||
return Some(session.to_owned());
|
||||
}
|
||||
let user_id = body.get("metadata")?.get("user_id")?.as_str()?.trim();
|
||||
if user_id.starts_with('{') {
|
||||
let metadata: Value = serde_json::from_str(user_id).ok()?;
|
||||
return metadata
|
||||
.get("session_id")?
|
||||
.as_str()
|
||||
.and_then(valid_session_id)
|
||||
.map(str::to_owned);
|
||||
}
|
||||
let (_, session) = user_id.rsplit_once("_session_")?;
|
||||
let session = valid_session_id(session)?;
|
||||
session
|
||||
.bytes()
|
||||
.all(|byte| byte.is_ascii_hexdigit() || byte == b'-')
|
||||
.then(|| session.to_owned())
|
||||
}
|
||||
|
||||
fn valid_session_id(value: &str) -> Option<&str> {
|
||||
if value.chars().any(char::is_control) {
|
||||
return None;
|
||||
}
|
||||
let value = value.trim();
|
||||
(!value.is_empty() && value.len() <= 256).then_some(value)
|
||||
}
|
||||
@@ -3,5 +3,6 @@
|
||||
mod capabilities;
|
||||
mod request;
|
||||
mod response;
|
||||
mod session;
|
||||
mod stream;
|
||||
mod usage;
|
||||
|
||||
@@ -0,0 +1,69 @@
|
||||
//! Claude Code 会话来源优先级、格式兼容与无效身份边界
|
||||
|
||||
use gateway_protocol::anthropic::claude_session_id;
|
||||
use serde_json::json;
|
||||
|
||||
#[test]
|
||||
fn explicit_claude_sessions_follow_header_then_metadata() {
|
||||
let session = "12345678-1234-1234-1234-123456789abc";
|
||||
for (header, user_id, expected) in [
|
||||
(
|
||||
Some(" header-session "),
|
||||
json!("{\"session_id\":\"body-session\"}"),
|
||||
Some("header-session"),
|
||||
),
|
||||
(
|
||||
None,
|
||||
json!("{\"device_id\":\"device\",\"session_id\":\"body-session\"}"),
|
||||
Some("body-session"),
|
||||
),
|
||||
(
|
||||
None,
|
||||
json!(format!("user_device_account__session_{session}")),
|
||||
Some(session),
|
||||
),
|
||||
(
|
||||
Some(""),
|
||||
json!(format!("user_{}_session_{session}", "x".repeat(300))),
|
||||
Some(session),
|
||||
),
|
||||
(None, json!("ordinary-user-id"), None),
|
||||
(None, json!("{\"device_id\":\"device\"}"), None),
|
||||
(None, json!("{invalid}"), None),
|
||||
(None, json!({"session_id":"not-a-string"}), None),
|
||||
(None, json!("user_device_session_"), None),
|
||||
(None, json!("user_device_session_not-a-uuid"), None),
|
||||
] {
|
||||
let body =
|
||||
json!({"metadata":{"user_id":user_id},"messages":[{"role":"user","content":"hello"}]});
|
||||
assert_eq!(
|
||||
claude_session_id(body.as_object().unwrap(), header).as_deref(),
|
||||
expected
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn invalid_session_signals_do_not_bind_users_or_message_content() {
|
||||
for invalid in [String::new(), "x".repeat(257), "bad\nidentity".to_owned()] {
|
||||
let body = json!({"metadata":{"user_id":json!({"session_id":invalid}).to_string()}});
|
||||
assert_eq!(
|
||||
claude_session_id(body.as_object().unwrap(), Some(&invalid)),
|
||||
None
|
||||
);
|
||||
let fallback = json!({"metadata":{"user_id":"{\"session_id\":\"valid-fallback\"}"}});
|
||||
assert_eq!(
|
||||
claude_session_id(fallback.as_object().unwrap(), Some(&invalid)).as_deref(),
|
||||
Some("valid-fallback")
|
||||
);
|
||||
}
|
||||
assert_eq!(
|
||||
claude_session_id(
|
||||
json!({"messages":[{"role":"user","content":"same opening"}]})
|
||||
.as_object()
|
||||
.unwrap(),
|
||||
None
|
||||
),
|
||||
None
|
||||
);
|
||||
}
|
||||
@@ -114,6 +114,7 @@ impl SettingsStore for AdminSettingsStoreAdapter {
|
||||
"responses_max_decompressed_body_bytes".to_owned(),
|
||||
"rotation_strategy".to_owned(),
|
||||
"smart_scheduling_json".to_owned(),
|
||||
"quota_reset_window_weights_json".to_owned(),
|
||||
"min_codex_desktop_version".to_owned(),
|
||||
"min_codex_cli_version".to_owned(),
|
||||
"retention".to_owned(),
|
||||
|
||||
@@ -336,7 +336,8 @@ async fn connect(
|
||||
),
|
||||
};
|
||||
let analytics =
|
||||
postgres::PgRequestAnalyticsRepository::new(pool.clone(), observability_query_budget);
|
||||
postgres::PgRequestAnalyticsRepository::new(pool.clone(), observability_query_budget)
|
||||
.with_projection_work_mem_mb(config.pool.analytics_projection_work_mem_mb);
|
||||
Ok(StoreBundle {
|
||||
pool,
|
||||
analytics,
|
||||
|
||||
@@ -37,6 +37,7 @@ pub struct StorePoolConfig {
|
||||
pub max_connections: u32,
|
||||
pub acquire_timeout_seconds: u64,
|
||||
pub observability_timeout_seconds: u64,
|
||||
pub analytics_projection_work_mem_mb: Option<u32>,
|
||||
}
|
||||
|
||||
impl Default for StorePoolConfig {
|
||||
@@ -45,12 +46,15 @@ impl Default for StorePoolConfig {
|
||||
max_connections: 20,
|
||||
acquire_timeout_seconds: 5,
|
||||
observability_timeout_seconds: 120,
|
||||
analytics_projection_work_mem_mb: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl StorePoolConfig {
|
||||
pub(crate) fn validate(&self) -> StoreResult<()> {
|
||||
// PostgreSQL 以有符号 32 位的 kB 保存 work_mem,配置按整 MB 填写
|
||||
const MAX_WORK_MEM_MB: u32 = i32::MAX as u32 / 1024;
|
||||
if self.max_connections < 2 || self.acquire_timeout_seconds == 0 {
|
||||
return Err(StoreError::InvalidData {
|
||||
source: None,
|
||||
@@ -69,6 +73,18 @@ impl StorePoolConfig {
|
||||
message: "pool.observability_timeout_seconds must be positive and fit PostgreSQL statement_timeout".to_owned(),
|
||||
});
|
||||
}
|
||||
if self
|
||||
.analytics_projection_work_mem_mb
|
||||
.is_some_and(|mb| !(1..=MAX_WORK_MEM_MB).contains(&mb))
|
||||
{
|
||||
return Err(StoreError::InvalidData {
|
||||
source: None,
|
||||
entity: "store config",
|
||||
message: format!(
|
||||
"pool.analytics_projection_work_mem_mb must be between 1 and {MAX_WORK_MEM_MB}"
|
||||
),
|
||||
});
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
|
||||
@@ -658,20 +658,41 @@ fn account_costs(state: &MetricState) -> StoreResult<Vec<AccountCost>> {
|
||||
.collect())
|
||||
}
|
||||
|
||||
async fn retained_account_usage_range(
|
||||
snapshot: &mut AnalyticsSnapshot<'_>,
|
||||
now: DateTime<Utc>,
|
||||
) -> StoreResult<ObservabilityRange> {
|
||||
// 只为实际存在的数据规划时间桶,超长保留期不展开空白历史或溢出日期
|
||||
let (days, earliest): (i64, DateTime<Utc>) = sqlx::query_as(
|
||||
"select usage_retention_days, least(
|
||||
(select started_at from model_requests order by started_at, id limit 1),
|
||||
(select started_at from request_analytics_facts order by started_at, id limit 1),
|
||||
(select bucket_start from request_analytics_1h where collection = 'usage_contribution' order by bucket_start limit 1),
|
||||
$1::timestamptz - interval '1 day'
|
||||
) from runtime_settings where id = 1",
|
||||
)
|
||||
.bind(now)
|
||||
.fetch_one(&mut *snapshot.tx)
|
||||
.await
|
||||
.map_err(|error| postgres_unavailable("read retained account usage range", error))?;
|
||||
let duration =
|
||||
TimeDelta::try_days(days).ok_or_else(|| invalid("invalid account usage retention"))?;
|
||||
let start = now
|
||||
.checked_sub_signed(duration)
|
||||
.unwrap_or(earliest)
|
||||
.max(earliest);
|
||||
ObservabilityRange::new(start, now)
|
||||
}
|
||||
|
||||
pub(crate) async fn account_usage_sort_values(
|
||||
snapshot: &mut AnalyticsSnapshot<'_>,
|
||||
now: DateTime<Utc>,
|
||||
) -> StoreResult<(Vec<String>, Vec<i64>, Vec<Option<DateTime<Utc>>>)> {
|
||||
let days: i32 =
|
||||
sqlx::query_scalar("select usage_retention_days::integer from runtime_settings where id=1")
|
||||
.fetch_one(&mut *snapshot.tx)
|
||||
.await
|
||||
.map_err(|error| postgres_unavailable("read account usage retention", error))?;
|
||||
let range = retained_account_usage_range(snapshot, now).await?;
|
||||
let ids: Vec<String> = sqlx::query_scalar("select id from provider_accounts")
|
||||
.fetch_all(&mut *snapshot.tx)
|
||||
.await
|
||||
.map_err(|error| postgres_unavailable("read account usage sort identities", error))?;
|
||||
let range = ObservabilityRange::new(now - TimeDelta::days(i64::from(days)), now)?;
|
||||
let mut totals = BTreeMap::<String, MetricState>::new();
|
||||
for ((account, _), state) in snapshot.account_states(range, &ids, false).await? {
|
||||
totals.entry(account).or_default().merge(&state)?;
|
||||
@@ -699,11 +720,7 @@ pub(crate) async fn account_group_usage(
|
||||
}
|
||||
let mut snapshot = AnalyticsSnapshot::new_for_accounts(connection).await?;
|
||||
let now = Utc::now();
|
||||
let days: i32 =
|
||||
sqlx::query_scalar("select usage_retention_days::integer from runtime_settings where id=1")
|
||||
.fetch_one(&mut *snapshot.tx)
|
||||
.await
|
||||
.map_err(|error| postgres_unavailable("read group usage retention", error))?;
|
||||
let retained = retained_account_usage_range(&mut snapshot, now).await?;
|
||||
let memberships:Vec<(String,String)>=sqlx::query_as("select account_group_id,provider_account_id from account_group_accounts where account_group_id=any($1::text[])").bind(group_ids).fetch_all(&mut *snapshot.tx).await.map_err(|error|postgres_unavailable("read group usage membership",error))?;
|
||||
let ids = memberships
|
||||
.iter()
|
||||
@@ -711,7 +728,6 @@ pub(crate) async fn account_group_usage(
|
||||
.collect::<BTreeSet<_>>()
|
||||
.into_iter()
|
||||
.collect::<Vec<_>>();
|
||||
let retained = ObservabilityRange::new(now - TimeDelta::days(i64::from(days)), now)?;
|
||||
let today = ObservabilityRange::new(
|
||||
timezone
|
||||
.day_start(now)
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
|
||||
use super::*;
|
||||
|
||||
/// 输入 matching 提供 output_bucket、name 和完整事实列及 is_completed_usage
|
||||
/// 输入 matching 提供分组键、指标输入列及 is_completed_usage
|
||||
/// 精确分位数在整个结果组内计算,不把局部分位数合并成新的分位数
|
||||
pub(super) fn push_fact_aggregation(
|
||||
query: &mut QueryBuilder<Postgres>,
|
||||
|
||||
@@ -379,8 +379,17 @@ async fn rebuild_groups(
|
||||
rebuilt.insert((*key).clone(), MetricState::default());
|
||||
}
|
||||
// 等值桶键避免范围连接反复比较其他时间桶,范围和游标仍限定已发布前缀
|
||||
// 计数、费用和直方图复用匹配结果,只物化这些聚合需要的列
|
||||
let mut query = QueryBuilder::<Postgres>::new(
|
||||
"with matching as materialized (select mr.*,k.bucket_start as output_bucket,k.name,coalesce((",
|
||||
"with matching as materialized (select k.bucket_start as output_bucket,k.name,
|
||||
mr.started_at,mr.outcome,mr.client_status_code,mr.upstream_status_code,mr.attempt_count,
|
||||
mr.image_generation_succeeded,mr.error_kind,mr.ops_failure_count,mr.ops_rate_limited_count,
|
||||
mr.ops_auth_failure_count,mr.ops_provider_5xx_count,mr.input_tokens,mr.output_tokens,
|
||||
mr.cached_input_tokens,mr.cache_write_input_tokens,mr.reasoning_output_tokens,
|
||||
mr.image_input_tokens,mr.image_output_tokens,mr.total_tokens,
|
||||
mr.cost_source,mr.cost_currency,mr.cost_amount,mr.standard_cost_amount,mr.no_cache_cost_amount,
|
||||
mr.first_token_ms,mr.latency_ms,mr.admission_decision_ms,mr.account_selection_wait_ms,
|
||||
mr.upstream_response_ms,mr.capacity_used_slots,mr.capacity_total_slots,coalesce((",
|
||||
);
|
||||
query.push(completed_usage_fact_predicate("mr"))
|
||||
.push("),false) as is_completed_usage from jsonb_to_recordset(")
|
||||
|
||||
@@ -32,6 +32,7 @@ pub struct AnalyticsStatus {
|
||||
pub struct PgRequestAnalyticsRepository {
|
||||
pool: PgPool,
|
||||
query_budget: ObservabilityQueryBudget,
|
||||
projection_work_mem_mb: Option<u32>,
|
||||
billing_projector: Option<Arc<dyn UsageBillingProjector>>,
|
||||
}
|
||||
|
||||
@@ -41,10 +42,17 @@ impl PgRequestAnalyticsRepository {
|
||||
Self {
|
||||
pool,
|
||||
query_budget,
|
||||
projection_work_mem_mb: None,
|
||||
billing_projector: None,
|
||||
}
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn with_projection_work_mem_mb(mut self, work_mem_mb: Option<u32>) -> Self {
|
||||
self.projection_work_mem_mb = work_mem_mb;
|
||||
self
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn with_billing_projector(mut self, projector: Arc<dyn UsageBillingProjector>) -> Self {
|
||||
self.billing_projector = Some(projector);
|
||||
@@ -82,6 +90,10 @@ impl PgRequestAnalyticsRepository {
|
||||
transaction.commit().await.map_err(|error| postgres_unavailable("save analytics reset progress", error))?;
|
||||
return Ok(AnalyticsMaintenance { reset_progress: true, ..Default::default() });
|
||||
}
|
||||
if let Some(mb) = self.projection_work_mem_mb {
|
||||
sqlx::query("select set_config('work_mem',$1,true)").bind(format!("{mb}MB"))
|
||||
.execute(&mut *transaction).await.map_err(|error| postgres_unavailable("set analytics projection work_mem", error))?;
|
||||
}
|
||||
let mut result = AnalyticsMaintenance::default();
|
||||
// 历史删除可能一次排入大量旧任务,给仍存在的请求预留半批名额,避免实时统计饥饿
|
||||
// 其余名额仍按最早入队消费,两类任务都能前进;同一快照内选版本,沿用精确版本 ACK
|
||||
|
||||
@@ -144,8 +144,7 @@ impl PgProviderAccountRepository {
|
||||
query.push(" and not exists (select 1 from provider_account_model_catalogs c
|
||||
where c.account_id=provider_accounts.id and c.credential_revision=provider_accounts.credential_revision
|
||||
and c.plan_type is not distinct from provider_accounts.plan_type and c.document_hash=any(")
|
||||
.push_bind(hashes).push("::bytea[]) and c.observed_at > ").push_bind(DateTime::<Utc>::from(omit.observed_after))
|
||||
.push(" and c.observed_at <= ").push_bind(DateTime::<Utc>::from(omit.as_of))
|
||||
.push_bind(hashes).push("::bytea[]) and c.observed_at <= ").push_bind(DateTime::<Utc>::from(omit.as_of))
|
||||
.push(" and not (c.account_id=any(").push_bind(exceptions).push("::text[])))");
|
||||
}
|
||||
query.push(" order by provider_kind, name, id");
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
|
||||
use crate::{admin_store_error, postgres_unavailable};
|
||||
use async_trait::async_trait;
|
||||
use chrono::{DateTime, Utc};
|
||||
use chrono::{DateTime, TimeDelta, Utc};
|
||||
use gateway_admin::{
|
||||
model::retention::{RetentionPolicy, RetentionTarget},
|
||||
ports::{
|
||||
@@ -54,15 +54,26 @@ impl RetentionStore for PgRetentionRepository {
|
||||
policy: RetentionPolicy,
|
||||
limit: NonZeroU32,
|
||||
) -> AdminStoreResult<u64> {
|
||||
let oldest_sql = match target {
|
||||
RetentionTarget::ModelRequests => {
|
||||
"select completed_at from model_requests where outcome <> 'running' order by completed_at limit 1"
|
||||
}
|
||||
RetentionTarget::OpsEvents => {
|
||||
"select created_at from ops_events where model_request_id is null order by created_at limit 1"
|
||||
}
|
||||
RetentionTarget::AdminAuditEvents => {
|
||||
"select created_at from admin_audit_events order by created_at limit 1"
|
||||
}
|
||||
};
|
||||
let sql = match target {
|
||||
RetentionTarget::ModelRequests => {
|
||||
"delete from model_requests
|
||||
where ctid in (
|
||||
select ctid from model_requests
|
||||
where outcome <> 'running'
|
||||
and completed_at < $1 - ($2 * interval '1 day')
|
||||
and completed_at < $1
|
||||
order by completed_at
|
||||
limit $3
|
||||
limit $2
|
||||
for update skip locked
|
||||
)"
|
||||
}
|
||||
@@ -71,9 +82,9 @@ impl RetentionStore for PgRetentionRepository {
|
||||
where ctid in (
|
||||
select ctid from ops_events
|
||||
where model_request_id is null
|
||||
and created_at < $1 - ($2 * interval '1 day')
|
||||
and created_at < $1
|
||||
order by created_at
|
||||
limit $3
|
||||
limit $2
|
||||
for update skip locked
|
||||
)"
|
||||
}
|
||||
@@ -81,9 +92,9 @@ impl RetentionStore for PgRetentionRepository {
|
||||
"delete from admin_audit_events
|
||||
where ctid in (
|
||||
select ctid from admin_audit_events
|
||||
where created_at < $1 - ($2 * interval '1 day')
|
||||
where created_at < $1
|
||||
order by created_at
|
||||
limit $3
|
||||
limit $2
|
||||
for update skip locked
|
||||
)"
|
||||
}
|
||||
@@ -102,14 +113,25 @@ impl RetentionStore for PgRetentionRepository {
|
||||
.execute(&mut *transaction)
|
||||
.await
|
||||
.map_err(|source| unavailable("set retention lock timeout", source))?;
|
||||
let deleted = sqlx::query(sql)
|
||||
.bind(now)
|
||||
.bind(i64::from(policy.days(target)))
|
||||
.bind(i64::from(limit.get()))
|
||||
.execute(&mut *transaction)
|
||||
let oldest: Option<DateTime<Utc>> = sqlx::query_scalar(oldest_sql)
|
||||
.fetch_optional(&mut *transaction)
|
||||
.await
|
||||
.map(|result| result.rows_affected())
|
||||
.map_err(|source| unavailable("delete expired records", source))?;
|
||||
.map_err(|source| unavailable("read oldest retained record", source))?;
|
||||
// 超长窗口覆盖全部现存记录时无需删除,也不向数据库传递越界日期
|
||||
let cutoff = now
|
||||
.checked_sub_signed(TimeDelta::days(i64::from(policy.days(target))))
|
||||
.filter(|cutoff| oldest.is_some_and(|oldest| oldest < *cutoff));
|
||||
let deleted = if let Some(cutoff) = cutoff {
|
||||
sqlx::query(sql)
|
||||
.bind(cutoff)
|
||||
.bind(i64::from(limit.get()))
|
||||
.execute(&mut *transaction)
|
||||
.await
|
||||
.map(|result| result.rows_affected())
|
||||
.map_err(|source| unavailable("delete expired records", source))?
|
||||
} else {
|
||||
0
|
||||
};
|
||||
transaction
|
||||
.commit()
|
||||
.await
|
||||
|
||||
@@ -153,7 +153,7 @@ pub(crate) async fn load_runtime_settings_from_pool(pool: &PgPool) -> StoreResul
|
||||
let row = sqlx::query_as::<_, RuntimeSettingsRow>(
|
||||
"select provider_request_profiles_json, config_revision, admin_api_key, refresh_margin_seconds, request_location_json, request_location_enabled, codex_privacy_policy_json,
|
||||
refresh_concurrency, max_concurrent_per_account,
|
||||
rotation_strategy, smart_scheduling_json, model_mappings_json, usage_retention_days, ops_event_retention_days,
|
||||
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,
|
||||
account_error_protection_json, account_error_protection_revision,
|
||||
@@ -195,6 +195,30 @@ impl ProviderRuntimePolicyPort for PgRuntimeSettingsRepository {
|
||||
Ok(claimed)
|
||||
})
|
||||
}
|
||||
fn load_request_profile<'a>(
|
||||
&'a self,
|
||||
provider: &'a gateway_core::routing::ProviderKind,
|
||||
) -> futures::future::BoxFuture<
|
||||
'a,
|
||||
Result<Option<gateway_core::account::OpaqueProviderData>, ProviderStoreError>,
|
||||
> {
|
||||
Box::pin(async move {
|
||||
let document = sqlx::query_scalar::<
|
||||
_,
|
||||
Option<sqlx::types::Json<serde_json::Map<String, serde_json::Value>>>,
|
||||
>(
|
||||
"select provider_request_profiles_json -> $1 from runtime_settings where id = 1",
|
||||
)
|
||||
.bind(provider.as_str())
|
||||
.fetch_one(&self.pool)
|
||||
.await
|
||||
.map_err(|source| {
|
||||
crate::provider_unavailable("load Provider request profile", source)
|
||||
})?;
|
||||
Ok(document.map(|document| gateway_core::account::OpaqueProviderData::new(document.0)))
|
||||
})
|
||||
}
|
||||
|
||||
fn initialize_request_profile<'a>(
|
||||
&'a self,
|
||||
provider: &'a gateway_core::routing::ProviderKind,
|
||||
@@ -296,7 +320,7 @@ impl ProviderRuntimePolicyPort for PgRuntimeSettingsRepository {
|
||||
.map_err(|source| crate::provider_unavailable("load warmup policy", source))?;
|
||||
ProviderWarmupPolicy::try_new(
|
||||
settings.values.account_warmup_enabled,
|
||||
settings.values.account_warmup_cron,
|
||||
&settings.values.account_warmup_cron,
|
||||
settings.values.account_warmup_model,
|
||||
)
|
||||
})
|
||||
@@ -309,7 +333,7 @@ pub(crate) async fn load_runtime_settings_in_transaction(
|
||||
let row = sqlx::query_as::<_, RuntimeSettingsRow>(
|
||||
"select provider_request_profiles_json, config_revision, admin_api_key, refresh_margin_seconds, request_location_json, request_location_enabled, codex_privacy_policy_json,
|
||||
refresh_concurrency, max_concurrent_per_account,
|
||||
rotation_strategy, smart_scheduling_json, model_mappings_json, usage_retention_days, ops_event_retention_days,
|
||||
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,
|
||||
account_error_protection_json, account_error_protection_revision,
|
||||
@@ -395,6 +419,7 @@ pub(crate) async fn update_runtime_settings_in_transaction(
|
||||
account_queue_timeout_seconds = $32,
|
||||
switch_account_on_queue_failure = $33,
|
||||
reset_credit_on_low_weekly_quota = $34,
|
||||
quota_reset_window_weights_json = $35,
|
||||
updated_at = now()
|
||||
where id = 1
|
||||
returning config_revision",
|
||||
@@ -441,6 +466,7 @@ pub(crate) async fn update_runtime_settings_in_transaction(
|
||||
.bind(i64::from(update.values.account_queue_timeout_seconds))
|
||||
.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))
|
||||
.fetch_optional(&mut **transaction)
|
||||
.await
|
||||
.map_err(|source| postgres_unavailable("update runtime settings in transaction", source))?
|
||||
@@ -514,6 +540,7 @@ struct RuntimeSettingsRow {
|
||||
refresh_concurrency: i64,
|
||||
max_concurrent_per_account: i64,
|
||||
smart_scheduling_json: sqlx::types::Json<gateway_core::account::SmartSchedulingConfig>,
|
||||
quota_reset_window_weights_json: sqlx::types::Json<gateway_core::account::ResetWindowWeights>,
|
||||
rotation_strategy: String,
|
||||
codex_privacy_policy_json:
|
||||
sqlx::types::Json<gateway_core::settings::privacy::CodexPrivacyPolicy>,
|
||||
@@ -576,6 +603,7 @@ fn runtime_settings_from_row(row: RuntimeSettingsRow) -> StoreResult<RuntimeSett
|
||||
refresh_concurrency: to_u32(row.refresh_concurrency)?,
|
||||
max_concurrent_per_account: to_u32(row.max_concurrent_per_account)?,
|
||||
smart_scheduling: row.smart_scheduling_json.0,
|
||||
quota_reset_window_weights: row.quota_reset_window_weights_json.0,
|
||||
codex_privacy_policy: row.codex_privacy_policy_json.0,
|
||||
request_location_enabled: row.request_location_enabled,
|
||||
request_location: row
|
||||
|
||||
@@ -221,6 +221,7 @@ struct SnapshotSettingsRow {
|
||||
account_error_protection_json: sqlx::types::Json<gateway_core::account::AccountErrorProtection>,
|
||||
max_concurrent_per_account: i64,
|
||||
smart_scheduling_json: sqlx::types::Json<gateway_core::account::SmartSchedulingConfig>,
|
||||
quota_reset_window_weights_json: sqlx::types::Json<gateway_core::account::ResetWindowWeights>,
|
||||
rotation_strategy: String,
|
||||
model_mappings_json: sqlx::types::Json<BTreeMap<String, String>>,
|
||||
min_codex_desktop_version: Option<String>,
|
||||
@@ -248,7 +249,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, 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_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
|
||||
@@ -281,6 +282,7 @@ async fn load_settings(
|
||||
.with_max_retry_after_seconds(to_u32(row.max_retry_after_seconds)?)
|
||||
.with_openai_session_affinity_ttl_hours(to_u32(row.openai_session_affinity_ttl_hours)?)
|
||||
.with_smart_scheduling(row.smart_scheduling_json.0)
|
||||
.with_quota_reset_window_weights(row.quota_reset_window_weights_json.0)
|
||||
.with_request_profiles(decode_request_profiles(
|
||||
row.provider_request_profiles_json.0,
|
||||
)?)
|
||||
|
||||
@@ -7,7 +7,7 @@ const PASSWORD: &str = "111111111111111111111111111111111111111111111111";
|
||||
#[test]
|
||||
fn store_config_should_derive_backup_staging_from_runtime_data_dir() {
|
||||
let root = tempfile::tempdir().expect("runtime data root");
|
||||
let mut config = valid_config();
|
||||
let mut config = config_with_pool(serde_json::json!({}));
|
||||
|
||||
config
|
||||
.resolve_and_validate(root.path())
|
||||
@@ -28,6 +28,7 @@ fn store_pool_config_defaults_reserve_capacity_for_observability() {
|
||||
assert_eq!(pool.max_connections, 20);
|
||||
assert_eq!(pool.acquire_timeout_seconds, 5);
|
||||
assert_eq!(pool.observability_timeout_seconds, 120);
|
||||
assert_eq!(pool.analytics_projection_work_mem_mb, None);
|
||||
assert_eq!(pool.observability_max_connections(), 16);
|
||||
assert_eq!(
|
||||
StorePoolConfig {
|
||||
@@ -68,7 +69,7 @@ fn store_config_rejects_a_pool_that_cannot_reserve_both_traffic_classes() {
|
||||
));
|
||||
}
|
||||
|
||||
fn valid_config() -> StoreConfig {
|
||||
fn config_with_pool(pool: serde_json::Value) -> StoreConfig {
|
||||
serde_json::from_value(serde_json::json!({
|
||||
"database": {
|
||||
"url": "postgres://codex_proxy@127.0.0.1:5432/codex_proxy",
|
||||
@@ -78,10 +79,29 @@ fn valid_config() -> StoreConfig {
|
||||
"url": "redis://127.0.0.1:6379/",
|
||||
"password": PASSWORD,
|
||||
},
|
||||
"pool": pool,
|
||||
}))
|
||||
.expect("test Store configuration")
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn analytics_projection_work_mem_accepts_whole_mb_within_postgres_limits() {
|
||||
let root = tempfile::tempdir().unwrap();
|
||||
for mb in [1_u32, 8, 2_097_151] {
|
||||
config_with_pool(serde_json::json!({"analytics_projection_work_mem_mb": mb}))
|
||||
.resolve_and_validate(root.path())
|
||||
.unwrap();
|
||||
}
|
||||
for mb in [0_u32, 2_097_152] {
|
||||
let error = config_with_pool(serde_json::json!({"analytics_projection_work_mem_mb": mb}))
|
||||
.resolve_and_validate(root.path())
|
||||
.unwrap_err();
|
||||
assert!(
|
||||
matches!(error, StoreError::InvalidData { message, .. } if message.contains("analytics_projection_work_mem_mb"))
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn store_config_accepts_custom_observability_timeout_and_rejects_invalid_values() {
|
||||
let root = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -693,9 +693,16 @@ async fn group_costs_follow_current_members_and_pending_source_replacements() {
|
||||
}
|
||||
}
|
||||
assert!(ready, "group fixture must publish rollups");
|
||||
let costs = load_retained_group_costs(&groups).await;
|
||||
assert_eq!(costs[MIXED_GROUP], "3.25");
|
||||
assert_eq!(costs[EMPTY_GROUP], "0");
|
||||
for days in [31_i64, 365, i64::from(u32::MAX)] {
|
||||
sqlx::query("update runtime_settings set usage_retention_days=$1")
|
||||
.bind(days)
|
||||
.execute(&database.pool)
|
||||
.await
|
||||
.unwrap();
|
||||
let costs = load_retained_group_costs(&groups).await;
|
||||
assert_eq!(costs[MIXED_GROUP], "3.25");
|
||||
assert_eq!(costs[EMPTY_GROUP], "0");
|
||||
}
|
||||
|
||||
sqlx::query("update account_group_accounts set account_group_id=$1 where provider_account_id='acct_group_move'")
|
||||
.bind(EMPTY_GROUP).execute(&database.pool).await.unwrap();
|
||||
|
||||
@@ -316,6 +316,80 @@ async fn incremental_deletions_repair_extrema_last_usage_and_zero_currency_prese
|
||||
database.close().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn projection_work_mem_is_local_to_the_worker_transaction() {
|
||||
let Some(database) = TestDatabase::create("work_mem").await else {
|
||||
return;
|
||||
};
|
||||
let pool = sqlx::postgres::PgPoolOptions::new()
|
||||
.max_connections(1)
|
||||
.connect_with(database.pool.connect_options().as_ref().clone())
|
||||
.await
|
||||
.unwrap();
|
||||
// 固定同一会话,直接记录事实写入和队列确认时的值,并在复用连接时检查恢复
|
||||
sqlx::raw_sql(
|
||||
"set work_mem='2MB';
|
||||
create table work_mem_audit(stage text, value text);
|
||||
create function record_work_mem() returns trigger language plpgsql as $$
|
||||
begin
|
||||
insert into work_mem_audit values (tg_argv[0], current_setting('work_mem'));
|
||||
return null;
|
||||
end $$;
|
||||
create trigger audit_fact after insert on request_analytics_facts
|
||||
for each row execute function record_work_mem('projection');
|
||||
create trigger audit_ack after delete on request_analytics_pending_requests
|
||||
for each row execute function record_work_mem('ack')",
|
||||
)
|
||||
.execute(&pool)
|
||||
.await
|
||||
.unwrap();
|
||||
let worker = PgRequestAnalyticsRepository::new(pool.clone(), observability_query_budget());
|
||||
let session = || {
|
||||
sqlx::query_as::<_, (i32, String)>("select pg_backend_pid(), current_setting('work_mem')")
|
||||
};
|
||||
let original = session().fetch_one(&pool).await.unwrap();
|
||||
for (worker, expected) in [
|
||||
(worker.clone(), "2MB"),
|
||||
(worker.with_projection_work_mem_mb(Some(8)), "8MB"),
|
||||
] {
|
||||
seed(&pool, expected, hour(), &[]).await;
|
||||
assert_eq!(worker.maintain(10).await.unwrap().projected_requests, 1);
|
||||
let audit: Vec<(String, String)> =
|
||||
sqlx::query_as("select stage, value from work_mem_audit order by stage")
|
||||
.fetch_all(&pool)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
audit,
|
||||
[
|
||||
("ack".into(), "2MB".into()),
|
||||
("projection".into(), expected.into())
|
||||
]
|
||||
);
|
||||
assert_eq!(session().fetch_one(&pool).await.unwrap(), original);
|
||||
sqlx::query("truncate work_mem_audit")
|
||||
.execute(&pool)
|
||||
.await
|
||||
.unwrap();
|
||||
}
|
||||
// 事实写入失败时投影事务回滚,原会话仍可供下一轮使用
|
||||
sqlx::query("alter table work_mem_audit add check (value <> '8MB')")
|
||||
.execute(&pool)
|
||||
.await
|
||||
.unwrap();
|
||||
seed(&pool, "rollback", hour(), &[]).await;
|
||||
let worker = PgRequestAnalyticsRepository::new(pool.clone(), observability_query_budget())
|
||||
.with_projection_work_mem_mb(Some(8));
|
||||
let error = worker.maintain(10).await.unwrap_err();
|
||||
assert!(
|
||||
error.to_string().contains("project analytics facts"),
|
||||
"{error}"
|
||||
);
|
||||
assert_eq!(session().fetch_one(&pool).await.unwrap(), original);
|
||||
pool.close().await;
|
||||
database.close().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn incremental_summary_write_failure_rolls_back_facts_and_preserves_queue() {
|
||||
let Some(database) = TestDatabase::create("analytics_incremental_rollback").await else {
|
||||
|
||||
@@ -170,7 +170,7 @@ async fn bulk_catalog_restore_keeps_ten_thousand_owners_and_fences_late_writes()
|
||||
.iter()
|
||||
.all(|a| !matches!(a.account_id.as_str(), "acct_1" | "acct_2" | "acct_3"))
|
||||
);
|
||||
// 数据库只能排除有当前版本、未过期的账号证据;显式例外仍进入选号
|
||||
// 刷新到期不改变目录排除结果;凭据变化与显式例外仍进入选号
|
||||
let hash: Vec<u8> = sqlx::query_scalar("select sha256($1::bytea)")
|
||||
.bind(&document)
|
||||
.fetch_one(&database.pool)
|
||||
@@ -181,7 +181,6 @@ async fn bulk_catalog_restore_keeps_ten_thousand_owners_and_fences_late_writes()
|
||||
let filter = gateway_core::account::AccountCatalogOmissions {
|
||||
documents: vec![hash.try_into().unwrap()],
|
||||
exceptions: vec![ProviderAccountId::new("acct_5").unwrap()],
|
||||
observed_after: now - std::time::Duration::from_secs(1800),
|
||||
as_of: now,
|
||||
};
|
||||
let ids = (1..=10000)
|
||||
@@ -195,9 +194,6 @@ async fn bulk_catalog_restore_keeps_ten_thousand_owners_and_fences_late_writes()
|
||||
.iter()
|
||||
.map(|a| a.id().as_str())
|
||||
.collect::<std::collections::BTreeSet<_>>();
|
||||
assert_eq!(
|
||||
ids,
|
||||
std::collections::BTreeSet::from(["acct_1", "acct_4", "acct_5"])
|
||||
);
|
||||
assert_eq!(ids, std::collections::BTreeSet::from(["acct_1", "acct_5"]));
|
||||
database.close().await;
|
||||
}
|
||||
|
||||
@@ -105,6 +105,11 @@ async fn quota_windows_reconcile_moved_requests_and_pending_deletions_without_wa
|
||||
assert_eq!(new.usage.reasoning_output_tokens, None);
|
||||
assert_eq!(new.usage.models[0].model, "new-model");
|
||||
assert_eq!(new.usage.costs[0].amount.as_str(), "4.75");
|
||||
sqlx::query("update runtime_settings set usage_retention_days=$1")
|
||||
.bind(i64::from(u32::MAX))
|
||||
.execute(&database.pool)
|
||||
.await
|
||||
.unwrap();
|
||||
for field in [AccountSortField::Usage, AccountSortField::LastUsedAt] {
|
||||
let ranked = store
|
||||
.list_accounts(
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
//! 验证短保留期升级、分批清理边界与统计异步收敛期间的查询可用性
|
||||
//! 验证保留期读写、分批清理边界与统计异步收敛期间的查询可用性
|
||||
|
||||
use std::{num::NonZeroU32, time::Duration};
|
||||
|
||||
@@ -20,6 +20,66 @@ use super::{
|
||||
observability_query_budget, observability_repository,
|
||||
};
|
||||
|
||||
#[tokio::test]
|
||||
async fn long_retention_round_trips_and_cleans_only_expired_requests() {
|
||||
use gateway_store::postgres::{PgRuntimeSettingsRepository, RuntimeSettingsRepository};
|
||||
|
||||
let Some(database) = TestDatabase::create("long_retention").await else {
|
||||
return;
|
||||
};
|
||||
let settings = PgRuntimeSettingsRepository::new(database.pool.clone());
|
||||
let retention = PgRetentionRepository::new(database.pool.clone());
|
||||
let now = Utc::now();
|
||||
for (id, age) in [("old", 400), ("month", 40), ("recent", 1)] {
|
||||
seed(&database.pool, id, now - ChronoDuration::days(age), &[]).await;
|
||||
}
|
||||
for (days, expected_deleted) in [(u32::MAX, 0), (3650, 0), (365, 1), (32, 1), (1, 0)] {
|
||||
let mut update = super::runtime_settings::settings_with_margin(300);
|
||||
update.values.usage_retention_days = days;
|
||||
settings.update_runtime_settings(update).await.unwrap();
|
||||
assert_eq!(
|
||||
settings
|
||||
.load_runtime_settings()
|
||||
.await
|
||||
.unwrap()
|
||||
.values
|
||||
.usage_retention_days,
|
||||
days
|
||||
);
|
||||
let policy = retention.load_policy().await.unwrap();
|
||||
assert_eq!(policy.days(RetentionTarget::ModelRequests), days);
|
||||
assert_eq!(
|
||||
retention
|
||||
.purge_batch(
|
||||
RetentionTarget::ModelRequests,
|
||||
now,
|
||||
policy,
|
||||
NonZeroU32::new(10).unwrap()
|
||||
)
|
||||
.await
|
||||
.unwrap(),
|
||||
expected_deleted
|
||||
);
|
||||
}
|
||||
let mut invalid = super::runtime_settings::settings_with_margin(300);
|
||||
invalid.values.usage_retention_days = 0;
|
||||
assert!(settings.update_runtime_settings(invalid).await.is_err());
|
||||
assert_eq!(
|
||||
retention
|
||||
.load_policy()
|
||||
.await
|
||||
.unwrap()
|
||||
.days(RetentionTarget::ModelRequests),
|
||||
1
|
||||
);
|
||||
let remaining: Vec<String> = sqlx::query_scalar("select id from model_requests order by id")
|
||||
.fetch_all(&database.pool)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(remaining, ["recent"]);
|
||||
database.close().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn short_retention_keeps_statistics_readable_until_each_deletion_batch_is_projected() {
|
||||
use gateway_admin::model::observability::{AnalyticsState, DashboardQuery, TimeRange};
|
||||
|
||||
@@ -40,6 +40,7 @@ pub(super) fn settings_with_margin(refresh_margin_seconds: u64) -> RuntimeSettin
|
||||
openai_session_affinity_ttl_hours: 24,
|
||||
responses_max_decompressed_body_bytes: 64 * 1024 * 1024,
|
||||
smart_scheduling: gateway_core::account::SmartSchedulingConfig::default(),
|
||||
quota_reset_window_weights: gateway_core::account::ResetWindowWeights::default(),
|
||||
min_codex_desktop_version: None,
|
||||
min_codex_cli_version: None,
|
||||
usage_retention_days: 31,
|
||||
@@ -113,7 +114,7 @@ async fn privacy_policy_defaults_off_and_round_trips_in_snapshot() {
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn smart_settings_round_trip_publish_and_restore_database_defaults() {
|
||||
async fn scheduling_settings_round_trip_publish_and_restore_database_defaults() {
|
||||
use gateway_core::account::SmartSchedulingConfig;
|
||||
use gateway_store::postgres::{PgRuntimeSnapshotRepository, RuntimeSnapshotRepository};
|
||||
let Some(database) = TestDatabase::create("smart_config").await else {
|
||||
@@ -126,6 +127,8 @@ async fn smart_settings_round_trip_publish_and_restore_database_defaults() {
|
||||
SmartSchedulingConfig::default()
|
||||
);
|
||||
let mut update = settings_with_margin(3600);
|
||||
let windows = gateway_core::account::ResetWindowWeights::new([0.0, 1.5, 0.0]).unwrap();
|
||||
update.values.quota_reset_window_weights = windows;
|
||||
let expected = serde_json::json!({
|
||||
"loadWeight": 0.0, "quotaWeight": 2.0, "healthWeight": 1.0, "latencyWeight": 0.5, "resetWeight": 1.2, "queueWeight": 2.3,
|
||||
"resetWindowWeights": {"fiveHour":2.0,"weekly":8.0,"monthly":0.0}
|
||||
@@ -137,12 +140,17 @@ async fn smart_settings_round_trip_publish_and_restore_database_defaults() {
|
||||
serde_json::to_value(reloaded.values.smart_scheduling).unwrap(),
|
||||
expected
|
||||
);
|
||||
assert_eq!(reloaded.values.quota_reset_window_weights, windows);
|
||||
let snapshot = PgRuntimeSnapshotRepository::new(database.pool.clone())
|
||||
.load_runtime_snapshot()
|
||||
.await
|
||||
.unwrap();
|
||||
let snapshot_values = serde_json::to_value(&snapshot.settings).unwrap();
|
||||
assert_eq!(snapshot_values["smart_scheduling"], expected);
|
||||
assert_eq!(
|
||||
snapshot_values["quota_reset_window_weights"],
|
||||
serde_json::to_value(windows).unwrap()
|
||||
);
|
||||
assert!(snapshot.config_revision > before.config_revision);
|
||||
sqlx::query("update runtime_settings set smart_scheduling_json = default where id = 1")
|
||||
.execute(&database.pool)
|
||||
@@ -183,7 +191,7 @@ async fn warmup_settings_round_trip_with_database_constraint() {
|
||||
let repository = PgRuntimeSettingsRepository::new(database.pool.clone());
|
||||
let mut update = settings_with_margin(3_600);
|
||||
update.values.account_warmup_enabled = true;
|
||||
update.values.account_warmup_cron = "0 8,13 * * MON-FRI".to_owned();
|
||||
update.values.account_warmup_cron = "0 8,13 * * MON-FRI;59 10 * * *".to_owned();
|
||||
update.values.account_warmup_model = Some("test-model".to_owned());
|
||||
repository
|
||||
.update_runtime_settings(update)
|
||||
@@ -195,7 +203,10 @@ async fn warmup_settings_round_trip_with_database_constraint() {
|
||||
.await
|
||||
.expect("load warmup settings");
|
||||
assert!(settings.values.account_warmup_enabled);
|
||||
assert_eq!(settings.values.account_warmup_cron, "0 8,13 * * MON-FRI");
|
||||
assert_eq!(
|
||||
settings.values.account_warmup_cron,
|
||||
"0 8,13 * * MON-FRI;59 10 * * *"
|
||||
);
|
||||
assert_eq!(
|
||||
settings.values.account_warmup_model.as_deref(),
|
||||
Some("test-model")
|
||||
@@ -1012,6 +1023,13 @@ async fn request_profile_projection_is_revision_consistent_and_includes_key_over
|
||||
};
|
||||
let repository = PgRuntimeSettingsRepository::new(database.pool.clone());
|
||||
let provider = ProviderKind::new("xai").unwrap();
|
||||
assert!(
|
||||
repository
|
||||
.load_request_profile(&provider)
|
||||
.await
|
||||
.unwrap()
|
||||
.is_none()
|
||||
);
|
||||
let document = |marker: &str| {
|
||||
OpaqueProviderData::new(
|
||||
serde_json::json!({"marker":marker})
|
||||
@@ -1053,6 +1071,10 @@ async fn request_profile_projection_is_revision_consistent_and_includes_key_over
|
||||
assert_eq!(profiles.len(), 2);
|
||||
assert!(profiles.contains(&document("global")));
|
||||
assert!(profiles.contains(&document("key")));
|
||||
assert_eq!(
|
||||
repository.load_request_profile(&provider).await.unwrap(),
|
||||
Some(document("global"))
|
||||
);
|
||||
|
||||
repository
|
||||
.update_runtime_settings(settings_with_margin(7200))
|
||||
|
||||
@@ -1957,6 +1957,11 @@ fn map_quota_error(error: CodexCredentialQuotaError) -> ProviderAdminError {
|
||||
use CodexCredentialQuotaError as Error;
|
||||
use ProviderAdminErrorKind as Kind;
|
||||
let (kind, public_message, upstream_message) = match error {
|
||||
Error::Profile(source) => {
|
||||
return provider_admin_error(Kind::Unavailable)
|
||||
.with_public_message("OpenAI 账号预热客户端身份不可用")
|
||||
.with_source(source);
|
||||
}
|
||||
Error::InvalidCredentialData => (
|
||||
Kind::Invalid,
|
||||
"OpenAI 额度查询凭据无效,请检查账号授权",
|
||||
@@ -2131,6 +2136,11 @@ fn map_catalog_error(error: CodexCredentialCatalogError) -> ProviderAdminError {
|
||||
"OpenAI 模型查询失败,请检查出站连接与上游服务",
|
||||
),
|
||||
Error::Cache => (Kind::Unavailable, "OpenAI 模型目录缓存暂不可用"),
|
||||
Error::Profile(source) => {
|
||||
return provider_admin_error(Kind::Unavailable)
|
||||
.with_public_message("OpenAI 模型目录客户端身份不可用")
|
||||
.with_source(source);
|
||||
}
|
||||
};
|
||||
provider_admin_error(kind).with_public_message(message)
|
||||
}
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
//! 逻辑会话账号绑定与线程传输隔离键的单向派生
|
||||
|
||||
use gateway_core::operation::RawJsonPayload;
|
||||
use gateway_core::operation::{ProtocolPayload, RawJsonPayload};
|
||||
use gateway_core::policy::ClientApiKeyId;
|
||||
use gateway_core::provider_ports::{ProviderSessionAffinityKey, ProviderSessionAlias};
|
||||
use serde_json::{Map, Value};
|
||||
@@ -148,6 +148,38 @@ pub(crate) fn derive_codex_session_affinity(
|
||||
.map(|affinity| affinity.with_follow_only(request.client_account_follow_only))
|
||||
}
|
||||
|
||||
/// Messages 的会话只参与账号绑定,不解释为 OpenAI 轮次或原生续接身份
|
||||
pub(crate) fn derive_messages_session_affinity(
|
||||
payload: &ProtocolPayload,
|
||||
headers: &[gateway_core::engine::middleware::MiddlewareHeader],
|
||||
client_api_key_id: &ClientApiKeyId,
|
||||
) -> Option<CodexSessionAffinity> {
|
||||
if payload.protocol() != gateway_protocol::anthropic::ANTHROPIC_PROTOCOL {
|
||||
return None;
|
||||
}
|
||||
let passthrough = crate::transport::request::decode_passthrough_headers(payload.context());
|
||||
let header = headers
|
||||
.iter()
|
||||
.find(|header| {
|
||||
header
|
||||
.name()
|
||||
.eq_ignore_ascii_case("x-claude-code-session-id")
|
||||
})
|
||||
.map(|header| std::str::from_utf8(header.value()).ok())
|
||||
.unwrap_or_else(|| {
|
||||
passthrough
|
||||
.get("x-claude-code-session-id")
|
||||
.and_then(|value| value.to_str().ok())
|
||||
});
|
||||
let session = gateway_protocol::anthropic::claude_session_id(payload.body(), header)?;
|
||||
session_affinity(
|
||||
"claude-session",
|
||||
&session,
|
||||
Some(&session),
|
||||
client_api_key_id,
|
||||
)
|
||||
}
|
||||
|
||||
/// 仅供选号使用。缓存键与输入正文均不作为会话、轮次或传输身份。
|
||||
pub(crate) fn derive_cache_preference(
|
||||
request: &CodexResponsesRequest,
|
||||
|
||||
@@ -15,6 +15,7 @@ use gateway_core::account::{
|
||||
};
|
||||
use gateway_core::provider_ports::{
|
||||
ProviderCatalogCacheKey, ProviderCatalogCachePort, ProviderCatalogScope,
|
||||
ProviderRuntimePolicyPort,
|
||||
};
|
||||
use gateway_core::routing::{
|
||||
FrozenAccountScope, ModelPresentation, ProviderCatalogGeneration, ProviderKind,
|
||||
@@ -32,8 +33,7 @@ use crate::transport::{CodexBackendClient, CodexCatalogModel, CodexRequestContex
|
||||
|
||||
const MAX_RESPONSE_ETAG_BYTES: usize = 256;
|
||||
const ACCOUNT_CATALOG_CACHE_TTL: Duration = Duration::from_secs(5 * 60);
|
||||
// 调度证据覆盖默认 15 分钟刷新周期及抖动,长期未刷新时恢复上游验证
|
||||
const SCHEDULING_CATALOG_MAX_AGE: Duration = Duration::from_secs(30 * 60);
|
||||
const CATALOG_REFRESH_AFTER: Duration = Duration::from_secs(30 * 60);
|
||||
const MAX_ACCOUNT_CATALOG_MODELS: usize = 2_048;
|
||||
const MODEL_CATALOG_TIMEOUT: Duration = Duration::from_secs(15);
|
||||
|
||||
@@ -141,7 +141,6 @@ impl CatalogContent {
|
||||
struct AccountEntry {
|
||||
observed_at: SystemTime,
|
||||
content: Arc<CatalogContent>,
|
||||
invalidated: Arc<std::sync::atomic::AtomicBool>,
|
||||
etag: Option<String>,
|
||||
}
|
||||
|
||||
@@ -197,13 +196,7 @@ impl CodexCredentialCatalogSnapshot {
|
||||
pub(super) fn excludes(&self, account: &ProviderAccount, model: &str, now: SystemTime) -> bool {
|
||||
self.entries
|
||||
.get(&CodexCatalogScope::for_account(account))
|
||||
.is_some_and(|e| {
|
||||
!e.invalidated.load(std::sync::atomic::Ordering::Relaxed)
|
||||
&& now
|
||||
.duration_since(e.observed_at)
|
||||
.is_ok_and(|age| age < SCHEDULING_CATALOG_MAX_AGE)
|
||||
&& !e.content.ids.iter().any(|id| id == model)
|
||||
})
|
||||
.is_some_and(|e| e.observed_at <= now && !e.content.ids.iter().any(|id| id == model))
|
||||
}
|
||||
|
||||
pub fn account_models(&self, account: &ProviderAccount) -> Option<&[String]> {
|
||||
@@ -251,6 +244,8 @@ pub enum CodexCredentialCatalogError {
|
||||
InvalidEtag,
|
||||
#[error("Codex model catalog changed during refresh")]
|
||||
ConcurrentUpdate,
|
||||
#[error("Codex model catalog client profile is unavailable")]
|
||||
Profile(#[source] gateway_core::error::ErrorSource),
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
@@ -281,6 +276,7 @@ pub struct CodexCredentialCatalogService {
|
||||
http: reqwest::Client,
|
||||
base_url: String,
|
||||
account_catalog_cache: Arc<dyn ProviderCatalogCachePort>,
|
||||
runtime_policy: Arc<dyn ProviderRuntimePolicyPort>,
|
||||
cache: Arc<RwLock<CatalogCacheState>>,
|
||||
refresh_notification: Arc<Notify>,
|
||||
refresh_lock: Arc<tokio::sync::Mutex<()>>,
|
||||
@@ -294,6 +290,7 @@ impl CodexCredentialCatalogService {
|
||||
http: reqwest::Client,
|
||||
base_url: String,
|
||||
account_catalog_cache: Arc<dyn ProviderCatalogCachePort>,
|
||||
runtime_policy: Arc<dyn ProviderRuntimePolicyPort>,
|
||||
) -> Self {
|
||||
Self {
|
||||
repository,
|
||||
@@ -301,6 +298,7 @@ impl CodexCredentialCatalogService {
|
||||
http,
|
||||
base_url,
|
||||
account_catalog_cache,
|
||||
runtime_policy,
|
||||
cache: Arc::new(RwLock::new(CatalogCacheState::default())),
|
||||
refresh_notification: Arc::new(Notify::new()),
|
||||
refresh_lock: Arc::new(tokio::sync::Mutex::new(())),
|
||||
@@ -308,6 +306,21 @@ impl CodexCredentialCatalogService {
|
||||
}
|
||||
}
|
||||
|
||||
/// 每轮发现冻结一次全局画像,使目录的版本参数与请求头使用同一身份
|
||||
async fn discovery_client(&self) -> Result<CodexBackendClient, CodexCredentialCatalogError> {
|
||||
let profile = self
|
||||
.profile
|
||||
.resolve_global_request_profile(self.runtime_policy.as_ref())
|
||||
.await
|
||||
.map_err(CodexCredentialCatalogError::Profile)?;
|
||||
let client = CodexBackendClient::new(
|
||||
self.http.clone(),
|
||||
self.base_url.clone(),
|
||||
self.profile.clone(),
|
||||
);
|
||||
Ok(client.with_request_profile(profile))
|
||||
}
|
||||
|
||||
/// 原生条目取自后台发现的账号目录;用当前账号版本和冻结的 Key 政策双重过滤
|
||||
pub async fn client_model_catalog(
|
||||
&self,
|
||||
@@ -466,14 +479,7 @@ impl CodexCredentialCatalogService {
|
||||
if ids.len() < MIN_CATALOG_PUSHDOWN {
|
||||
return None;
|
||||
}
|
||||
let cache = self.cache.read().ok()?;
|
||||
let snapshot = cache.snapshot.as_ref()?.clone();
|
||||
let pending = cache
|
||||
.pending
|
||||
.keys()
|
||||
.map(|s| s.account_id.clone())
|
||||
.collect::<BTreeSet<_>>();
|
||||
drop(cache);
|
||||
let snapshot = self.cached().ok()??;
|
||||
let documents = snapshot
|
||||
.sources
|
||||
.iter()
|
||||
@@ -483,16 +489,10 @@ impl CodexCredentialCatalogService {
|
||||
if documents.is_empty() {
|
||||
return None;
|
||||
}
|
||||
let as_of = SystemTime::now();
|
||||
Some(gateway_core::account::AccountCatalogOmissions {
|
||||
documents,
|
||||
exceptions: ids
|
||||
.iter()
|
||||
.filter(|id| pending.contains(*id) || exempt(id))
|
||||
.cloned()
|
||||
.collect(),
|
||||
observed_after: as_of.checked_sub(SCHEDULING_CATALOG_MAX_AGE)?,
|
||||
as_of,
|
||||
exceptions: ids.iter().filter(|id| exempt(id)).cloned().collect(),
|
||||
as_of: SystemTime::now(),
|
||||
})
|
||||
}
|
||||
|
||||
@@ -521,11 +521,7 @@ impl CodexCredentialCatalogService {
|
||||
.filter(|account| account.provider().as_str() == "openai")
|
||||
.ok_or(CodexCredentialCatalogError::NoEligibleCredential)?;
|
||||
let scope = CodexCatalogScope::for_account(&account);
|
||||
let client = CodexBackendClient::new(
|
||||
self.http.clone(),
|
||||
self.base_url.clone(),
|
||||
self.profile.clone(),
|
||||
);
|
||||
let client = self.discovery_client().await?;
|
||||
let revision = self.state_revision()?;
|
||||
let (catalog, entry) = self
|
||||
.fetch_observation(&client, &account, &scope, None)
|
||||
@@ -582,7 +578,6 @@ impl CodexCredentialCatalogService {
|
||||
observed_at,
|
||||
content,
|
||||
etag: observed.etag,
|
||||
invalidated: Default::default(),
|
||||
},
|
||||
))
|
||||
}
|
||||
@@ -595,11 +590,7 @@ impl CodexCredentialCatalogService {
|
||||
&self,
|
||||
account: &ProviderAccount,
|
||||
) -> Result<(Vec<CodexCatalogModel>, SystemTime), CodexCredentialCatalogError> {
|
||||
let client = CodexBackendClient::new(
|
||||
self.http.clone(),
|
||||
self.base_url.clone(),
|
||||
self.profile.clone(),
|
||||
);
|
||||
let client = self.discovery_client().await?;
|
||||
let fetched = self.fetch_account_models(&client, account).await?;
|
||||
if fetched.models.is_empty() {
|
||||
return Err(CodexCredentialCatalogError::NoEligibleCredential);
|
||||
|
||||
@@ -41,7 +41,6 @@ impl CodexCredentialCatalogService {
|
||||
observed_at: a.observed_at,
|
||||
content: content.clone(),
|
||||
etag: a.etag,
|
||||
invalidated: Default::default(),
|
||||
},
|
||||
);
|
||||
}
|
||||
@@ -131,11 +130,6 @@ impl CodexCredentialCatalogService {
|
||||
{
|
||||
return Ok(false);
|
||||
}
|
||||
if let Some(entry) = state.snapshot.as_ref().and_then(|s| s.entries.get(&scope)) {
|
||||
entry
|
||||
.invalidated
|
||||
.store(true, std::sync::atomic::Ordering::Relaxed);
|
||||
}
|
||||
state.pending.insert(scope, etag.to_owned());
|
||||
drop(state);
|
||||
self.refresh_notification.notify_one();
|
||||
@@ -210,15 +204,12 @@ impl CodexCredentialCatalogService {
|
||||
let Some(entry) = snapshot.entries.get(scope) else {
|
||||
return true;
|
||||
};
|
||||
if entry.etag.as_deref() == Some(tag)
|
||||
&& !entry.invalidated.load(std::sync::atomic::Ordering::Relaxed)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
entry
|
||||
.invalidated
|
||||
.store(true, std::sync::atomic::Ordering::Relaxed);
|
||||
true
|
||||
// 发布其他账号时保留通知,只有该账号更新的观测才能确认 ETag
|
||||
entry.etag.as_deref() != Some(tag)
|
||||
|| old
|
||||
.as_ref()
|
||||
.and_then(|s| s.entries.get(scope))
|
||||
.is_some_and(|previous| previous.observed_at >= entry.observed_at)
|
||||
});
|
||||
}
|
||||
cache.snapshot = next.clone();
|
||||
@@ -289,7 +280,7 @@ impl CodexCredentialCatalogService {
|
||||
pending.contains_key(scope)
|
||||
|| !entries.get(scope).is_some_and(|e| {
|
||||
now.duration_since(e.observed_at)
|
||||
.is_ok_and(|age| age < SCHEDULING_CATALOG_MAX_AGE)
|
||||
.is_ok_and(|age| age < CATALOG_REFRESH_AFTER)
|
||||
})
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
@@ -298,11 +289,7 @@ impl CodexCredentialCatalogService {
|
||||
.cached()?
|
||||
.ok_or(CodexCredentialCatalogError::NoEligibleCredential);
|
||||
}
|
||||
let client = CodexBackendClient::new(
|
||||
self.http.clone(),
|
||||
self.base_url.clone(),
|
||||
self.profile.clone(),
|
||||
);
|
||||
let client = self.discovery_client().await?;
|
||||
let mut pace = tokio::time::interval(REFRESH_SPACING);
|
||||
pace.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
|
||||
let starts = stream::unfold(pace, |mut clock| async move {
|
||||
|
||||
@@ -22,7 +22,8 @@ pub(crate) use affinity::{
|
||||
CodexSessionAffinity, derive_cache_preference, derive_codex_cyber_policy_session_key,
|
||||
derive_codex_endpoint_session_affinity, derive_codex_session_affinity,
|
||||
derive_codex_transport_key, derive_endpoint_affinity_with_headers,
|
||||
derive_live_session_affinity, derive_previous_response_id_hash, derive_turn_alias,
|
||||
derive_live_session_affinity, derive_messages_session_affinity,
|
||||
derive_previous_response_id_hash, derive_turn_alias,
|
||||
};
|
||||
pub(crate) use eligibility::CodexSelectionModel;
|
||||
pub(crate) use oauth::oauth_owner_ref;
|
||||
|
||||
@@ -140,6 +140,8 @@ pub struct CodexWarmupSummary {
|
||||
|
||||
#[derive(Debug, Error)]
|
||||
pub enum CodexCredentialQuotaError {
|
||||
#[error("Codex warmup client profile is unavailable")]
|
||||
Profile(#[source] gateway_core::error::ErrorSource),
|
||||
#[error("Codex quota response is invalid")]
|
||||
InvalidCredentialData,
|
||||
#[error("Codex OAuth access token must be refreshed before querying quota")]
|
||||
|
||||
@@ -140,11 +140,17 @@ impl CodexCredentialQuotaService {
|
||||
})
|
||||
.collect::<BTreeMap<_, _>>();
|
||||
|
||||
let profile = self
|
||||
.profile
|
||||
.resolve_global_request_profile(self.runtime_policy.as_ref())
|
||||
.await
|
||||
.map_err(CodexCredentialQuotaError::Profile)?;
|
||||
let client = CodexBackendClient::new(
|
||||
self.http.clone(),
|
||||
self.base_url.clone(),
|
||||
self.profile.clone(),
|
||||
);
|
||||
)
|
||||
.with_request_profile(profile);
|
||||
|
||||
for account in accounts {
|
||||
if account.quota().is_exhausted() {
|
||||
|
||||
@@ -152,6 +152,7 @@ pub async fn initialize(
|
||||
http.clone(),
|
||||
config.base_url().to_owned(),
|
||||
ports.catalog_cache(),
|
||||
ports.runtime_policy(),
|
||||
));
|
||||
if let Err(error) = catalog.restore().await {
|
||||
tracing::warn!(%error,"OpenAI model catalog could not be restored");
|
||||
|
||||
@@ -30,6 +30,26 @@ impl CodexProvider {
|
||||
if !matches!(source, OPENAI_PROTOCOL | ANTHROPIC_PROTOCOL) {
|
||||
return Err(invalid_request());
|
||||
}
|
||||
if !context.is_diagnostic_required_account()
|
||||
&& (source == ANTHROPIC_PROTOCOL
|
||||
|| selected.lease.authentication().api_protocol() == ApiKeyProtocol::Messages)
|
||||
{
|
||||
// attempt 改写后的身份必须在跨协议转换前复验,避免绕过已有账号绑定
|
||||
let affinity = crate::credential::derive_messages_session_affinity(
|
||||
generate.protocol_payload(),
|
||||
&headers,
|
||||
context.client_api_key_ref(),
|
||||
);
|
||||
self.selector
|
||||
.validate_translated_selection(
|
||||
&mut selected.lease,
|
||||
affinity.as_ref(),
|
||||
None,
|
||||
context.account_selection_policy(),
|
||||
)
|
||||
.await
|
||||
.map_err(map_selection_error)?;
|
||||
}
|
||||
if selected.lease.authentication().api_protocol() == ApiKeyProtocol::Messages {
|
||||
if context.continuation_attempt() == ContinuationAttempt::Native
|
||||
|| generate.provider_session_state(PROVIDER_NAME).is_some()
|
||||
@@ -124,21 +144,10 @@ impl CodexProvider {
|
||||
selected: SelectedGenerate,
|
||||
) -> Result<ProviderStream, ProviderError> {
|
||||
let SelectedGenerate {
|
||||
mut lease,
|
||||
lease,
|
||||
account_selection_wait_ms,
|
||||
..
|
||||
} = selected;
|
||||
if !context.is_diagnostic_required_account() {
|
||||
self.selector
|
||||
.validate_translated_selection(
|
||||
&mut lease,
|
||||
None,
|
||||
None,
|
||||
context.account_selection_policy(),
|
||||
)
|
||||
.await
|
||||
.map_err(map_selection_error)?;
|
||||
}
|
||||
self.messages_stream(
|
||||
body,
|
||||
source_context,
|
||||
|
||||
@@ -673,8 +673,7 @@ impl Provider for CodexProvider {
|
||||
{
|
||||
return Err(continuation_replay_required_error("scope_unavailable"));
|
||||
}
|
||||
// 其他协议必须先取得真实账号,再按固定 attempt 阶段调用转换器;选号前不能
|
||||
// 把未知正文当成 OpenAI wire 解释会话、亲和或传输字段
|
||||
// 跨协议转换必须在选号后执行;选号前只按各自协议读取明确会话身份
|
||||
let upstream = (generate.protocol_payload().protocol() == OPENAI_PROTOCOL)
|
||||
.then(|| encode_generate_request(generate, upstream_model.as_str(), None))
|
||||
.transpose()
|
||||
@@ -726,10 +725,16 @@ impl Provider for CodexProvider {
|
||||
requires_websocket,
|
||||
)
|
||||
});
|
||||
// 内容亲和只交给选号器;中间件复验、轮次关联和原生续接仍只认真实会话
|
||||
let messages_affinity = crate::credential::derive_messages_session_affinity(
|
||||
generate.protocol_payload(),
|
||||
&[],
|
||||
context.client_api_key_ref(),
|
||||
);
|
||||
// Messages 身份与内容亲和仅交给选号器,不建立 OpenAI 轮次或原生续接关联
|
||||
let account_affinity = selection_session_affinity
|
||||
.as_ref()
|
||||
.or(cache_preference.as_ref());
|
||||
.or(cache_preference.as_ref())
|
||||
.or(messages_affinity.as_ref());
|
||||
let selection_started_at = Instant::now();
|
||||
let selection = async {
|
||||
self.selector
|
||||
|
||||
@@ -15,7 +15,7 @@ use super::{
|
||||
};
|
||||
|
||||
impl CodexBackendClient {
|
||||
/// 客户端目录按调用方版本协商;后台目录仍使用经过核验的服务端画像版本
|
||||
/// 目录优先使用显式协商版本,否则沿用调用方冻结的画像版本
|
||||
pub async fn fetch_models_with_context(
|
||||
&self,
|
||||
context: CodexRequestContext<'_>,
|
||||
|
||||
@@ -11,7 +11,7 @@ use super::{
|
||||
CodexRequestContext, CodexTransportMetrics, elapsed_duration_millis, http_version_name,
|
||||
},
|
||||
endpoints::endpoint_url,
|
||||
headers::insert_optional_protocol_header,
|
||||
headers::{insert_optional_header, insert_optional_protocol_header},
|
||||
response_meta,
|
||||
};
|
||||
|
||||
@@ -41,6 +41,11 @@ impl CodexBackendClient {
|
||||
};
|
||||
let profile = self.profile.snapshot();
|
||||
let mut headers = self.model_request_headers(&profile, context)?;
|
||||
insert_optional_header(
|
||||
&mut headers,
|
||||
"x-codex-installation-id",
|
||||
context.installation_id,
|
||||
)?;
|
||||
super::headers::append_passthrough_headers(&mut headers, passthrough_headers);
|
||||
// 独立端点没有 Responses 原连接归属,续接状态不能跨账号继承
|
||||
// turn metadata 随后仅使用当前 lease 已处理的值
|
||||
|
||||
@@ -19,7 +19,7 @@ use super::{
|
||||
},
|
||||
diagnostics::CodexUpstreamDiagnostics,
|
||||
endpoints::endpoint_url,
|
||||
headers::is_managed_identity_header,
|
||||
headers::{insert_optional_header, is_managed_identity_header},
|
||||
response_meta,
|
||||
};
|
||||
|
||||
@@ -33,6 +33,11 @@ impl CodexBackendClient {
|
||||
) -> CodexClientResult<HeaderMap> {
|
||||
let profile = self.profile.snapshot();
|
||||
let mut headers = self.model_request_headers(&profile, context)?;
|
||||
insert_optional_header(
|
||||
&mut headers,
|
||||
"x-codex-installation-id",
|
||||
context.installation_id,
|
||||
)?;
|
||||
for header in extra_protocol_headers {
|
||||
let name = HeaderName::from_bytes(header.name().as_bytes())?;
|
||||
if is_managed_identity_header(name.as_str())
|
||||
|
||||
@@ -41,12 +41,35 @@ fn scoped_id(installation_id: &str, original: &str) -> String {
|
||||
let hash = digest.finalize();
|
||||
let mut bytes = [0_u8; 16];
|
||||
bytes.copy_from_slice(&hash[..16]);
|
||||
// 保持官方 UUID 的形状;各类引用共享映射,保留相同原值的等值关系
|
||||
bytes[6] = (bytes[6] & 0x0f) | 0x40;
|
||||
if let Some(id) = uuid::Uuid::parse_str(original).ok().filter(|id| {
|
||||
id.get_version() == Some(uuid::Version::SortRand)
|
||||
&& id.get_variant() == uuid::Variant::RFC4122
|
||||
}) {
|
||||
// 官方线程与会话使用 UUIDv7;保留毫秒时间,仅按账号隔离随机部分
|
||||
bytes[..6].copy_from_slice(&id.as_bytes()[..6]);
|
||||
bytes[6] = (bytes[6] & 0x0f) | 0x70;
|
||||
} else {
|
||||
// 自定义缓存键及非 v7 标识沿用稳定映射,不为它们补造创建时间
|
||||
bytes[6] = (bytes[6] & 0x0f) | 0x40;
|
||||
}
|
||||
bytes[8] = (bytes[8] & 0x3f) | 0x80;
|
||||
uuid::Uuid::from_bytes(bytes).to_string()
|
||||
}
|
||||
|
||||
fn scoped_field_id(installation_id: &str, field: &str, original: &str) -> String {
|
||||
// context_window_id 是独立标识,仅官方复合窗口字段引用 thread_id
|
||||
if matches!(field, "window_id" | "x-codex-window-id" | "codexWindowId")
|
||||
&& let Some((thread_id, number)) = original.split_once(':')
|
||||
&& uuid::Uuid::parse_str(thread_id).is_ok()
|
||||
&& number
|
||||
.parse::<u64>()
|
||||
.is_ok_and(|value| value.to_string() == number)
|
||||
{
|
||||
return format!("{}:{number}", scoped_id(installation_id, thread_id));
|
||||
}
|
||||
scoped_id(installation_id, original)
|
||||
}
|
||||
|
||||
/// Search 的 id 是会话关联键,仅替换该值的原始字节,保留其他字段、重复键和空白
|
||||
pub(super) fn scope_search_body(body: bytes::Bytes, installation_id: Option<&str>) -> bytes::Bytes {
|
||||
#[derive(serde::Deserialize)]
|
||||
@@ -85,7 +108,7 @@ fn map_fields(object: &mut Map<String, Value>, installation_id: &str, fields: &[
|
||||
if let Some(Value::String(value)) = object.get_mut(*key)
|
||||
&& !value.is_empty()
|
||||
{
|
||||
*value = scoped_id(installation_id, value);
|
||||
*value = scoped_field_id(installation_id, key, value);
|
||||
changed += 1;
|
||||
}
|
||||
}
|
||||
@@ -123,7 +146,7 @@ pub(super) fn scope_headers(headers: &mut HeaderMap, installation_id: Option<&st
|
||||
.ok()
|
||||
.filter(|value| !value.is_empty())
|
||||
.and_then(|value| {
|
||||
HeaderValue::from_str(&scoped_id(installation_id, value)).ok()
|
||||
HeaderValue::from_str(&scoped_field_id(installation_id, name, value)).ok()
|
||||
})
|
||||
.unwrap_or_else(|| value.clone())
|
||||
})
|
||||
|
||||
@@ -28,7 +28,7 @@ pub(super) fn is_managed_identity_header(name: &str) -> bool {
|
||||
| "chatgpt-project-id"
|
||||
| "openai-organization"
|
||||
| "openai-project"
|
||||
// 安装头与 client_metadata 共用本次请求的安装身份
|
||||
// 安装身份由所选账号生成,不继承下游安装头
|
||||
| "x-codex-installation-id"
|
||||
// 画像和设备证明须属于选定账号,不能由下游覆盖
|
||||
| "originator"
|
||||
@@ -138,11 +138,6 @@ impl CodexBackendClient {
|
||||
};
|
||||
let mut headers = build_codex_model_headers(profile, context.authorization, account_id)?;
|
||||
insert_optional_header(&mut headers, "cookie", cookie_header)?;
|
||||
insert_optional_header(
|
||||
&mut headers,
|
||||
"x-codex-installation-id",
|
||||
context.installation_id,
|
||||
)?;
|
||||
Ok(headers)
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,117 @@
|
||||
//! OpenAI 客户端的离线版本、制品身份与预设环境默认值
|
||||
//!
|
||||
//! 更新时一并核验配套版本、构建号、时间及各架构制品身份
|
||||
//! 各平台分别核验,版本相同不表示可以借用另一平台的资料
|
||||
|
||||
use chrono::{DateTime, Utc};
|
||||
|
||||
pub(super) const DESKTOP_ORIGINATOR: &str = "Codex Desktop";
|
||||
pub(super) const CLI_ORIGINATOR: &str = "codex_cli_rs";
|
||||
pub(super) const TUI_ORIGINATOR: &str = "codex-tui";
|
||||
pub(super) const EXEC_ORIGINATOR: &str = "codex_exec";
|
||||
pub(super) const TERMINAL: &str = "unknown";
|
||||
|
||||
pub(super) struct Environment {
|
||||
pub os_type: &'static str,
|
||||
pub os_version: &'static str,
|
||||
pub arch: &'static str,
|
||||
}
|
||||
|
||||
pub(super) const MACOS_ENVIRONMENT: Environment = Environment {
|
||||
os_type: "Mac OS",
|
||||
os_version: "15.7.1",
|
||||
arch: "arm64",
|
||||
};
|
||||
pub(super) const LINUX_ENVIRONMENT: Environment = Environment {
|
||||
os_type: "Linux",
|
||||
os_version: "6.8.0",
|
||||
arch: "x86_64",
|
||||
};
|
||||
pub(super) const WINDOWS_ENVIRONMENT: Environment = Environment {
|
||||
os_type: "Windows",
|
||||
os_version: "10.0.26100",
|
||||
arch: "x86_64",
|
||||
};
|
||||
|
||||
pub(super) struct CoreRelease {
|
||||
pub version: &'static str,
|
||||
pub verified_at_millis: i64,
|
||||
}
|
||||
|
||||
impl CoreRelease {
|
||||
pub fn verified_at(&self) -> DateTime<Utc> {
|
||||
DateTime::UNIX_EPOCH + chrono::Duration::milliseconds(self.verified_at_millis)
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) struct DesktopRelease {
|
||||
pub core: CoreRelease,
|
||||
pub version: &'static str,
|
||||
pub build: &'static str,
|
||||
}
|
||||
|
||||
pub(super) struct DesktopArtifact {
|
||||
pub arch: &'static str,
|
||||
pub size: u64,
|
||||
pub etag: &'static str,
|
||||
}
|
||||
|
||||
// 官方 npm 稳定标签及六个平台依赖;核验于 2026-11-14T02:09:52Z
|
||||
pub(super) const CLI_RELEASE: CoreRelease = CoreRelease {
|
||||
version: "0.169.0",
|
||||
verified_at_millis: 1_794_622_192_000,
|
||||
};
|
||||
|
||||
// macOS arm64 ZIP;核验于 2026-11-14T02:09:52Z
|
||||
pub(super) const MACOS_RELEASE: DesktopRelease = DesktopRelease {
|
||||
core: CoreRelease {
|
||||
version: "0.169.0-alpha.11.1",
|
||||
verified_at_millis: 1_794_622_192_000,
|
||||
},
|
||||
version: "26.1111.21308",
|
||||
build: "27194",
|
||||
};
|
||||
|
||||
// Windows 两种架构的 MSIX;核验于 2026-11-14T02:09:52Z
|
||||
pub(super) const WINDOWS_RELEASE: DesktopRelease = DesktopRelease {
|
||||
core: CoreRelease {
|
||||
version: "0.167.0-alpha.4.1",
|
||||
verified_at_millis: 1_794_622_192_000,
|
||||
},
|
||||
version: "26.1106.51428",
|
||||
build: "26605",
|
||||
};
|
||||
pub(super) const WINDOWS_ARTIFACTS: [DesktopArtifact; 2] = [
|
||||
DesktopArtifact {
|
||||
arch: "x86_64",
|
||||
size: 1_057_680_859,
|
||||
etag: "\"0x8DF3FEB5404E49A\"",
|
||||
},
|
||||
DesktopArtifact {
|
||||
arch: "arm64",
|
||||
size: 1_158_775_140,
|
||||
etag: "\"0x8DF3FEB5ABF50ED\"",
|
||||
},
|
||||
];
|
||||
|
||||
// Linux 两种架构的 DEB;核验于 2026-11-14T02:09:52Z
|
||||
pub(super) const LINUX_RELEASE: DesktopRelease = DesktopRelease {
|
||||
core: CoreRelease {
|
||||
version: "0.169.0-alpha.11.1",
|
||||
verified_at_millis: 1_794_622_192_000,
|
||||
},
|
||||
version: "26.1111.21308",
|
||||
build: "27194",
|
||||
};
|
||||
pub(super) const LINUX_ARTIFACTS: [DesktopArtifact; 2] = [
|
||||
DesktopArtifact {
|
||||
arch: "x86_64",
|
||||
size: 567_877_422,
|
||||
etag: "\"0x8DF4126A0871331\"",
|
||||
},
|
||||
DesktopArtifact {
|
||||
arch: "arm64",
|
||||
size: 553_033_238,
|
||||
etag: "\"0x8DF41269D464E6A\"",
|
||||
},
|
||||
];
|
||||
@@ -1,18 +1,22 @@
|
||||
//! CLI 稳定发布来自官方 npm 包及其平台依赖,不与 Desktop 的内嵌版本混用
|
||||
|
||||
use std::collections::BTreeMap;
|
||||
use std::sync::Arc;
|
||||
use std::sync::{Arc, Mutex};
|
||||
use std::time::Duration;
|
||||
|
||||
use chrono::Utc;
|
||||
use futures::StreamExt as _;
|
||||
use futures::{StreamExt as _, future::BoxFuture};
|
||||
use gateway_core::provider_ports::{ProviderArtifactProfile, ProviderArtifactProfileCachePort};
|
||||
use gateway_core::routing::ProviderKind;
|
||||
use reqwest::{Client, redirect::Policy};
|
||||
use serde::Deserialize;
|
||||
use tokio::time::Instant;
|
||||
|
||||
use super::selection::{ClientKind, ClientPlatform, ClientRelease, object};
|
||||
use super::{ARTIFACT_PROFILE_CACHE_TTL, CodexWireProfileState};
|
||||
use super::{
|
||||
ARTIFACT_PROFILE_CACHE_RENEW_INTERVAL, ARTIFACT_PROFILE_CACHE_TTL, CodexWireProfileState,
|
||||
baseline,
|
||||
};
|
||||
|
||||
const ENDPOINT: &str = "https://registry.npmjs.org/@openai%2Fcodex/latest";
|
||||
const MAX_BYTES: usize = 256 * 1024;
|
||||
@@ -67,11 +71,21 @@ fn sequence(version: &str) -> Result<u64, CliReleaseError> {
|
||||
Ok(1 + version.major * 1_000_000 + version.minor * 1_000 + version.patch)
|
||||
}
|
||||
|
||||
pub struct CliReleaseService {
|
||||
/// 官方 npm 发布读取边界
|
||||
pub trait CliReleaseTransport: Send + Sync {
|
||||
fn fetch(&self) -> BoxFuture<'_, Result<String, CliReleaseError>>;
|
||||
}
|
||||
|
||||
struct OfficialCliReleaseTransport {
|
||||
client: Client,
|
||||
}
|
||||
|
||||
pub struct CliReleaseService {
|
||||
transport: Arc<dyn CliReleaseTransport>,
|
||||
provider: ProviderKind,
|
||||
state: CodexWireProfileState,
|
||||
cache: Arc<dyn ProviderArtifactProfileCachePort>,
|
||||
cache_writes: Mutex<BTreeMap<String, Instant>>,
|
||||
}
|
||||
|
||||
impl CliReleaseService {
|
||||
@@ -88,12 +102,27 @@ impl CliReleaseService {
|
||||
.timeout(Duration::from_secs(30))
|
||||
.build()
|
||||
.map_err(|_| CliReleaseError::Fetch)?;
|
||||
Ok(Self {
|
||||
client,
|
||||
Ok(Self::with_transport(
|
||||
provider,
|
||||
state,
|
||||
cache,
|
||||
})
|
||||
Arc::new(OfficialCliReleaseTransport { client }),
|
||||
))
|
||||
}
|
||||
|
||||
pub fn with_transport(
|
||||
provider: ProviderKind,
|
||||
state: CodexWireProfileState,
|
||||
cache: Arc<dyn ProviderArtifactProfileCachePort>,
|
||||
transport: Arc<dyn CliReleaseTransport>,
|
||||
) -> Self {
|
||||
Self {
|
||||
transport,
|
||||
provider,
|
||||
state,
|
||||
cache,
|
||||
cache_writes: Mutex::default(),
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn restore(&self) {
|
||||
@@ -135,7 +164,7 @@ impl CliReleaseService {
|
||||
}
|
||||
|
||||
pub async fn refresh(&self) -> Result<(), CliReleaseError> {
|
||||
let result = self.fetch().await;
|
||||
let result = self.transport.fetch().await;
|
||||
for (platform, arch, target) in TARGETS {
|
||||
let outcome = match &result {
|
||||
Ok(version) => self.publish(platform, arch, target, version).await,
|
||||
@@ -155,16 +184,29 @@ impl CliReleaseService {
|
||||
version: &str,
|
||||
) -> Result<ClientRelease, String> {
|
||||
let next = sequence(version).map_err(|error| error.to_string())?;
|
||||
if self
|
||||
.state
|
||||
.client_release(ClientKind::Cli, platform, arch)
|
||||
.is_some_and(|current| {
|
||||
sequence(¤t.codex_version).is_ok_and(|current| current > next)
|
||||
})
|
||||
{
|
||||
let current = self.state.client_release(ClientKind::Cli, platform, arch);
|
||||
if current.as_ref().is_some_and(|current| {
|
||||
sequence(¤t.codex_version).is_ok_and(|current| current > next)
|
||||
}) {
|
||||
return Err("官方 CLI 发布版本低于当前已核验版本".to_owned());
|
||||
}
|
||||
let verified_at = Utc::now();
|
||||
let unchanged = current.filter(|current| current.codex_version == version);
|
||||
if let Some(current) = &unchanged {
|
||||
let fresh = self
|
||||
.cache_writes
|
||||
.lock()
|
||||
.unwrap_or_else(std::sync::PoisonError::into_inner)
|
||||
.get(target)
|
||||
.is_some_and(|written| written.elapsed() < ARTIFACT_PROFILE_CACHE_RENEW_INTERVAL);
|
||||
if fresh {
|
||||
return Ok(current.clone());
|
||||
}
|
||||
}
|
||||
// 同版探测和缓存续期保留实际核验时间,只有新版才产生新的核验时间
|
||||
let verified_at = unchanged
|
||||
.as_ref()
|
||||
.and_then(|release| release.verified_at)
|
||||
.unwrap_or_else(Utc::now);
|
||||
let payload =
|
||||
object(&serde_json::json!({"version": version})).map_err(|error| error.to_string())?;
|
||||
let profile = ProviderArtifactProfile::new(
|
||||
@@ -179,58 +221,65 @@ impl CliReleaseService {
|
||||
.replace_if_newer(profile, ARTIFACT_PROFILE_CACHE_TTL)
|
||||
.await
|
||||
{
|
||||
Ok(true) => Ok(ClientRelease {
|
||||
codex_version: version.to_owned(),
|
||||
desktop_version: None,
|
||||
desktop_build: None,
|
||||
verified_at: Some(verified_at),
|
||||
}),
|
||||
Ok(true) => {
|
||||
self.cache_writes
|
||||
.lock()
|
||||
.unwrap_or_else(std::sync::PoisonError::into_inner)
|
||||
.insert(target.to_owned(), Instant::now());
|
||||
Ok(ClientRelease {
|
||||
codex_version: version.to_owned(),
|
||||
desktop_version: None,
|
||||
desktop_build: None,
|
||||
verified_at: Some(verified_at),
|
||||
})
|
||||
}
|
||||
Ok(false) => Err("CLI 发布缓存已更新,等待下次同步".to_owned()),
|
||||
Err(_) => Err("CLI 发布版本缓存写入失败".to_owned()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn fetch(&self) -> Result<String, CliReleaseError> {
|
||||
let response = self
|
||||
.client
|
||||
.get(ENDPOINT)
|
||||
.send()
|
||||
.await
|
||||
.map_err(|_| CliReleaseError::Fetch)?;
|
||||
if !response.status().is_success()
|
||||
|| response
|
||||
.content_length()
|
||||
.is_some_and(|length| length > MAX_BYTES as u64)
|
||||
{
|
||||
return Err(CliReleaseError::Fetch);
|
||||
}
|
||||
let mut bytes = Vec::new();
|
||||
let mut stream = response.bytes_stream();
|
||||
while let Some(chunk) = stream.next().await {
|
||||
let chunk = chunk.map_err(|_| CliReleaseError::Fetch)?;
|
||||
if bytes.len().saturating_add(chunk.len()) > MAX_BYTES {
|
||||
return Err(CliReleaseError::Invalid);
|
||||
impl CliReleaseTransport for OfficialCliReleaseTransport {
|
||||
fn fetch(&self) -> BoxFuture<'_, Result<String, CliReleaseError>> {
|
||||
Box::pin(async move {
|
||||
let response = self
|
||||
.client
|
||||
.get(ENDPOINT)
|
||||
.send()
|
||||
.await
|
||||
.map_err(|_| CliReleaseError::Fetch)?;
|
||||
if !response.status().is_success()
|
||||
|| response
|
||||
.content_length()
|
||||
.is_some_and(|length| length > MAX_BYTES as u64)
|
||||
{
|
||||
return Err(CliReleaseError::Fetch);
|
||||
}
|
||||
bytes.extend_from_slice(&chunk);
|
||||
}
|
||||
parse_cli_release(&bytes)
|
||||
let mut bytes = Vec::new();
|
||||
let mut stream = response.bytes_stream();
|
||||
while let Some(chunk) = stream.next().await {
|
||||
let chunk = chunk.map_err(|_| CliReleaseError::Fetch)?;
|
||||
if bytes.len().saturating_add(chunk.len()) > MAX_BYTES {
|
||||
return Err(CliReleaseError::Invalid);
|
||||
}
|
||||
bytes.extend_from_slice(&chunk);
|
||||
}
|
||||
parse_cli_release(&bytes)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn seed_releases(state: &CodexWireProfileState) {
|
||||
// 2026-09-18 核对官方 npm latest 及六个平台依赖;这里只提供离线启动资料
|
||||
for (platform, arch, _) in TARGETS {
|
||||
state.seed_client_release(
|
||||
ClientKind::Cli,
|
||||
platform,
|
||||
arch,
|
||||
ClientRelease {
|
||||
codex_version: "0.155.0".to_owned(),
|
||||
codex_version: baseline::CLI_RELEASE.version.to_owned(),
|
||||
desktop_version: None,
|
||||
desktop_build: None,
|
||||
verified_at: chrono::DateTime::parse_from_rfc3339("2026-09-18T00:00:00Z")
|
||||
.ok()
|
||||
.map(|time| time.with_timezone(&Utc)),
|
||||
verified_at: Some(baseline::CLI_RELEASE.verified_at()),
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
@@ -2,6 +2,9 @@
|
||||
|
||||
use chrono::DateTime;
|
||||
use gateway_core::account::OpaqueProviderData;
|
||||
use gateway_core::error::ErrorSource;
|
||||
use gateway_core::provider_ports::ProviderRuntimePolicyPort;
|
||||
use gateway_core::routing::ProviderKind;
|
||||
use serde::Deserialize;
|
||||
use serde_json::{Value, json};
|
||||
use sha2::{Digest, Sha256};
|
||||
@@ -11,6 +14,26 @@ use super::selection::{
|
||||
};
|
||||
use super::{CodexWireProfile, CodexWireProfileState};
|
||||
|
||||
impl CodexWireProfileState {
|
||||
/// 后台模型操作没有 Client Key,按当前全局选择冻结整套身份
|
||||
pub(crate) async fn resolve_global_request_profile(
|
||||
&self,
|
||||
policy: &dyn ProviderRuntimePolicyPort,
|
||||
) -> Result<CodexWireProfile, ErrorSource> {
|
||||
let provider = ProviderKind::new("openai").map_err(ErrorSource::new)?;
|
||||
let Some(configuration) = policy
|
||||
.load_request_profile(&provider)
|
||||
.await
|
||||
.map_err(ErrorSource::new)?
|
||||
else {
|
||||
return Ok(self.snapshot());
|
||||
};
|
||||
RequestProfileSelection::parse(&configuration)
|
||||
.and_then(|selection| selection.resolve(self))
|
||||
.map_err(ErrorSource::new)
|
||||
}
|
||||
}
|
||||
|
||||
/// 已解析的配置;没有 mode 的预设配置复用官方版本与平台合同
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct RequestProfileSelection {
|
||||
|
||||
@@ -20,6 +20,7 @@ use url::Url;
|
||||
|
||||
use self::desktop_artifact::{CodexDesktopArtifactError, fetch_codex_core_version};
|
||||
|
||||
mod baseline;
|
||||
pub mod cli_release;
|
||||
mod context;
|
||||
pub mod desktop_artifact;
|
||||
@@ -33,11 +34,12 @@ use selection::{ClientKind, ClientPlatform, ClientRelease};
|
||||
pub const CODEX_DESKTOP_APPCAST_URL: &str =
|
||||
"https://persistent.oaistatic.com/codex-app-prod/appcast.xml";
|
||||
/// 官方发布元数据检查周期
|
||||
pub const APPCAST_POLL_INTERVAL: Duration = Duration::from_secs(24 * 60 * 60);
|
||||
pub const APPCAST_POLL_INTERVAL: Duration = Duration::from_secs(60 * 60);
|
||||
|
||||
const APPCAST_TIMEOUT: Duration = Duration::from_secs(30);
|
||||
const MAX_APPCAST_BYTES: usize = 1024 * 1024;
|
||||
const ARTIFACT_PROFILE_CACHE_TTL: Duration = Duration::from_secs(30 * 24 * 60 * 60);
|
||||
const ARTIFACT_PROFILE_CACHE_RENEW_INTERVAL: Duration = Duration::from_secs(24 * 60 * 60);
|
||||
const ARTIFACT_PROFILE_SCHEMA_VERSION: u64 = 1;
|
||||
|
||||
/// 保留已有配置类型入口;位置规则由出口领域统一维护
|
||||
@@ -82,22 +84,23 @@ pub struct CodexWireProfile {
|
||||
|
||||
impl Default for CodexWireProfile {
|
||||
fn default() -> Self {
|
||||
let release = baseline::MACOS_RELEASE;
|
||||
let environment = baseline::MACOS_ENVIRONMENT;
|
||||
Self {
|
||||
client_kind: ClientKind::Desktop,
|
||||
originator: "Codex Desktop".to_owned(),
|
||||
codex_version: "0.153.4".to_owned(),
|
||||
desktop_version: "26.901.51231".to_owned(),
|
||||
desktop_build: "8109".to_owned(),
|
||||
os_type: "Mac OS".to_owned(),
|
||||
os_version: "15.7.1".to_owned(),
|
||||
arch: "arm64".to_owned(),
|
||||
terminal: "unknown".to_owned(),
|
||||
originator: baseline::DESKTOP_ORIGINATOR.to_owned(),
|
||||
codex_version: release.core.version.to_owned(),
|
||||
desktop_version: release.version.to_owned(),
|
||||
desktop_build: release.build.to_owned(),
|
||||
os_type: environment.os_type.to_owned(),
|
||||
os_version: environment.os_version.to_owned(),
|
||||
arch: environment.arch.to_owned(),
|
||||
terminal: baseline::TERMINAL.to_owned(),
|
||||
exact_user_agent: None,
|
||||
installation_seed: None,
|
||||
residency: None,
|
||||
account_routing_override: None,
|
||||
// 制品核验于 2026-09-06T03:26:12.084Z;进程启动不构成重新核验
|
||||
verified_at: DateTime::UNIX_EPOCH + chrono::Duration::milliseconds(1_788_665_172_084),
|
||||
verified_at: release.core.verified_at(),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -632,6 +635,7 @@ pub struct CodexDesktopReleaseService {
|
||||
profile: CodexWireProfileState,
|
||||
cache: CodexArtifactProfileCache,
|
||||
verified: Arc<RwLock<Option<CodexBundledReleaseProfile>>>,
|
||||
cache_written_at: Arc<RwLock<Option<tokio::time::Instant>>>,
|
||||
}
|
||||
|
||||
impl CodexDesktopReleaseService {
|
||||
@@ -666,6 +670,7 @@ impl CodexDesktopReleaseService {
|
||||
profile,
|
||||
cache,
|
||||
verified: Arc::new(RwLock::new(verified)),
|
||||
cache_written_at: Arc::default(),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -730,10 +735,24 @@ impl CodexDesktopReleaseService {
|
||||
{
|
||||
return Err(CodexDesktopReleaseError::InconsistentRelease);
|
||||
}
|
||||
if !self.cache.replace_if_newer(&verified).await? {
|
||||
return Err(CodexDesktopReleaseError::ReleaseRollback);
|
||||
// 轻量检查只推进观察时间,缓存单独按天续期
|
||||
let renewal_due = self
|
||||
.cache_written_at
|
||||
.read()
|
||||
.unwrap_or_else(std::sync::PoisonError::into_inner)
|
||||
.is_none_or(|written| {
|
||||
written.elapsed() >= ARTIFACT_PROFILE_CACHE_RENEW_INTERVAL
|
||||
});
|
||||
if renewal_due {
|
||||
if !self.cache.replace_if_newer(&verified).await? {
|
||||
return Err(CodexDesktopReleaseError::ReleaseRollback);
|
||||
}
|
||||
*self
|
||||
.cache_written_at
|
||||
.write()
|
||||
.unwrap_or_else(std::sync::PoisonError::into_inner) =
|
||||
Some(tokio::time::Instant::now());
|
||||
}
|
||||
self.profile.update_bundled_release(&verified);
|
||||
return Ok(release);
|
||||
}
|
||||
}
|
||||
@@ -764,6 +783,10 @@ impl CodexDesktopReleaseService {
|
||||
.verified
|
||||
.write()
|
||||
.unwrap_or_else(std::sync::PoisonError::into_inner) = Some(published);
|
||||
*self
|
||||
.cache_written_at
|
||||
.write()
|
||||
.unwrap_or_else(std::sync::PoisonError::into_inner) = Some(tokio::time::Instant::now());
|
||||
Ok(release)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -3,7 +3,10 @@
|
||||
use super::selection::{
|
||||
ClientKind, ClientPlatform, ClientProfileSelection, ClientRelease, VersionMode, object,
|
||||
};
|
||||
use super::{ARTIFACT_PROFILE_CACHE_TTL, CodexWireProfileState};
|
||||
use super::{
|
||||
ARTIFACT_PROFILE_CACHE_RENEW_INTERVAL, ARTIFACT_PROFILE_CACHE_TTL, CodexWireProfileState,
|
||||
baseline,
|
||||
};
|
||||
use chrono::Utc;
|
||||
use futures::future::BoxFuture;
|
||||
use gateway_core::provider_ports::{ProviderArtifactProfile, ProviderArtifactProfileCachePort};
|
||||
@@ -135,6 +138,7 @@ pub struct PlatformDesktopReleaseService {
|
||||
cache: Arc<dyn ProviderArtifactProfileCachePort>,
|
||||
transport: Arc<dyn DesktopArtifactTransport>,
|
||||
verified: Mutex<BTreeMap<DesktopTarget, VerifiedArtifact>>,
|
||||
cache_written_at: Mutex<BTreeMap<DesktopTarget, tokio::time::Instant>>,
|
||||
}
|
||||
impl PlatformDesktopReleaseService {
|
||||
pub fn new(
|
||||
@@ -149,6 +153,7 @@ impl PlatformDesktopReleaseService {
|
||||
cache,
|
||||
transport,
|
||||
verified: Mutex::new(baseline_artifacts()),
|
||||
cache_written_at: Mutex::default(),
|
||||
}
|
||||
}
|
||||
pub async fn restore(&self) {
|
||||
@@ -206,14 +211,32 @@ impl PlatformDesktopReleaseService {
|
||||
.cloned();
|
||||
let mut artifact = self
|
||||
.transport
|
||||
.fetch(target, previous)
|
||||
.fetch(target, previous.clone())
|
||||
.await
|
||||
.map_err(|error| error.to_string())?;
|
||||
let sequence = sequence(target, &artifact.release).map_err(|error| error.to_string())?;
|
||||
if !self.accepts(target, &artifact.release) {
|
||||
return Err("官方 Desktop 发布低于当前版本或同构建版本不一致".to_owned());
|
||||
}
|
||||
let verified_at = Utc::now();
|
||||
let unchanged = previous
|
||||
.as_ref()
|
||||
.is_some_and(|previous| previous.identity == artifact.identity);
|
||||
if unchanged
|
||||
&& self
|
||||
.cache_written_at
|
||||
.lock()
|
||||
.unwrap_or_else(std::sync::PoisonError::into_inner)
|
||||
.get(&target)
|
||||
.is_some_and(|written| written.elapsed() < ARTIFACT_PROFILE_CACHE_RENEW_INTERVAL)
|
||||
{
|
||||
return Ok(artifact.release);
|
||||
}
|
||||
// 相同制品只续期缓存,保留实际提取版本时的核验时间
|
||||
let verified_at = if unchanged {
|
||||
artifact.release.verified_at.unwrap_or_else(Utc::now)
|
||||
} else {
|
||||
Utc::now()
|
||||
};
|
||||
// 核验时间属于缓存信封,避免同构建重复检查被判定为不同制品
|
||||
artifact.release.verified_at = None;
|
||||
let payload =
|
||||
@@ -235,6 +258,10 @@ impl PlatformDesktopReleaseService {
|
||||
Ok(false) => return Err("Desktop 发布缓存已更新,等待下次同步".to_owned()),
|
||||
Err(_) => return Err("Desktop 发布缓存写入失败".to_owned()),
|
||||
}
|
||||
self.cache_written_at
|
||||
.lock()
|
||||
.unwrap_or_else(std::sync::PoisonError::into_inner)
|
||||
.insert(target, tokio::time::Instant::now());
|
||||
artifact.release.verified_at = Some(verified_at);
|
||||
self.verified
|
||||
.lock()
|
||||
@@ -280,43 +307,44 @@ fn sequence(target: DesktopTarget, release: &ClientRelease) -> io::Result<u64> {
|
||||
}
|
||||
|
||||
fn baseline_artifacts() -> BTreeMap<DesktopTarget, VerifiedArtifact> {
|
||||
// 2026-09-18 分别读取四个官方安装包,版本元组与 ETag 均来自同一个包
|
||||
// 离线可直接选择自动模式;ETag 变化后必须重新核验,不能延用另一平台的版本
|
||||
let identities = [
|
||||
(774_919_598, "\"0x8DF141FFDF86290\""),
|
||||
(771_727_321, "\"0x8DF14202C49201F\""),
|
||||
(417_337_930, "\"0x8DF150AE1091545\""),
|
||||
(395_993_890, "\"0x8DF150ADC810C82\""),
|
||||
];
|
||||
TARGETS
|
||||
.into_iter()
|
||||
.zip(identities)
|
||||
.map(|(target, (size, etag))| {
|
||||
let (core, version, build) = if target.platform == ClientPlatform::Windows {
|
||||
("0.154.0-alpha.6.2", "26.908.70816", "9275")
|
||||
} else {
|
||||
("0.155.0-alpha.9", "26.915.31029", "9771")
|
||||
};
|
||||
[
|
||||
(
|
||||
ClientPlatform::Windows,
|
||||
baseline::WINDOWS_RELEASE,
|
||||
baseline::WINDOWS_ARTIFACTS,
|
||||
),
|
||||
(
|
||||
ClientPlatform::Linux,
|
||||
baseline::LINUX_RELEASE,
|
||||
baseline::LINUX_ARTIFACTS,
|
||||
),
|
||||
]
|
||||
.into_iter()
|
||||
.flat_map(|(platform, release, artifacts)| {
|
||||
artifacts.into_iter().map(move |artifact| {
|
||||
(
|
||||
target,
|
||||
DesktopTarget {
|
||||
platform,
|
||||
arch: artifact.arch,
|
||||
},
|
||||
VerifiedArtifact {
|
||||
identity: ArtifactIdentity {
|
||||
size,
|
||||
etag: etag.to_owned(),
|
||||
},
|
||||
release: ClientRelease {
|
||||
codex_version: core.to_owned(),
|
||||
desktop_version: Some(version.to_owned()),
|
||||
desktop_build: Some(build.to_owned()),
|
||||
verified_at: chrono::DateTime::parse_from_rfc3339("2026-09-18T00:00:00Z")
|
||||
.ok()
|
||||
.map(|time| time.with_timezone(&Utc)),
|
||||
codex_version: release.core.version.to_owned(),
|
||||
desktop_version: Some(release.version.to_owned()),
|
||||
desktop_build: Some(release.build.to_owned()),
|
||||
verified_at: Some(release.core.verified_at()),
|
||||
},
|
||||
identity: ArtifactIdentity {
|
||||
size: artifact.size,
|
||||
etag: artifact.etag.to_owned(),
|
||||
},
|
||||
},
|
||||
)
|
||||
})
|
||||
.collect()
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
pub(super) fn seed_releases(state: &CodexWireProfileState) {
|
||||
for (target, artifact) in baseline_artifacts() {
|
||||
state.seed_client_release(
|
||||
|
||||
@@ -5,7 +5,7 @@ use gateway_core::account::OpaqueProviderData;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde_json::{Value, json};
|
||||
|
||||
use super::{CodexWireProfile, CodexWireProfileState};
|
||||
use super::{CodexWireProfile, CodexWireProfileState, baseline};
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "snake_case")]
|
||||
@@ -25,8 +25,8 @@ pub enum CliEntry {
|
||||
impl CliEntry {
|
||||
pub const fn originator(self) -> &'static str {
|
||||
match self {
|
||||
Self::Tui => "codex-tui",
|
||||
Self::Exec => "codex_exec",
|
||||
Self::Tui => baseline::TUI_ORIGINATOR,
|
||||
Self::Exec => baseline::EXEC_ORIGINATOR,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -41,25 +41,22 @@ pub enum ClientPlatform {
|
||||
|
||||
impl ClientPlatform {
|
||||
pub const fn os_type(self) -> &'static str {
|
||||
match self {
|
||||
Self::Macos => "Mac OS",
|
||||
Self::Linux => "Linux",
|
||||
Self::Windows => "Windows",
|
||||
}
|
||||
self.default_environment().os_type
|
||||
}
|
||||
|
||||
fn default_os_version(self) -> &'static str {
|
||||
match self {
|
||||
Self::Macos => "15.7.1",
|
||||
Self::Linux => "6.8.0",
|
||||
Self::Windows => "10.0.26100",
|
||||
}
|
||||
self.default_environment().os_version
|
||||
}
|
||||
|
||||
fn default_arch(self) -> &'static str {
|
||||
self.default_environment().arch
|
||||
}
|
||||
|
||||
const fn default_environment(self) -> baseline::Environment {
|
||||
match self {
|
||||
Self::Macos => "arm64",
|
||||
Self::Linux | Self::Windows => "x86_64",
|
||||
Self::Macos => baseline::MACOS_ENVIRONMENT,
|
||||
Self::Linux => baseline::LINUX_ENVIRONMENT,
|
||||
Self::Windows => baseline::WINDOWS_ENVIRONMENT,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -138,8 +135,10 @@ impl ClientProfileSelection {
|
||||
|
||||
fn default_originator(&self) -> &'static str {
|
||||
match self.client {
|
||||
ClientKind::Desktop => "Codex Desktop",
|
||||
ClientKind::Cli => self.cli_entry.map_or("codex_cli_rs", CliEntry::originator),
|
||||
ClientKind::Desktop => baseline::DESKTOP_ORIGINATOR,
|
||||
ClientKind::Cli => self
|
||||
.cli_entry
|
||||
.map_or(baseline::CLI_ORIGINATOR, CliEntry::originator),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -275,7 +274,7 @@ impl ClientProfileSelection {
|
||||
terminal: self
|
||||
.terminal
|
||||
.clone()
|
||||
.unwrap_or_else(|| "unknown".to_owned()),
|
||||
.unwrap_or_else(|| baseline::TERMINAL.to_owned()),
|
||||
exact_user_agent: None,
|
||||
installation_seed: None,
|
||||
residency: deployment.residency,
|
||||
@@ -283,7 +282,7 @@ impl ClientProfileSelection {
|
||||
verified_at: release.verified_at.unwrap_or(DateTime::UNIX_EPOCH),
|
||||
};
|
||||
if let Some(entry) = self.cli_entry {
|
||||
// 入口后缀使用同一次解析得到的 Core 版本,避免每日更新后头部与后缀混用
|
||||
// 入口后缀使用同一次解析得到的 Core 版本,避免版本更新后头部与后缀混用
|
||||
// originator 可单独覆盖;入口名与官方 clientInfo.name 的语义保持一致
|
||||
profile.exact_user_agent = Some(format!(
|
||||
"{} ({}; {})",
|
||||
@@ -370,7 +369,7 @@ impl CodexWireProfileState {
|
||||
"configuration": configuration,
|
||||
"automaticAvailable": available,
|
||||
"reason": (!available).then_some("暂不支持自动更新"),
|
||||
"defaults": { "originator": configuration.default_originator(), "osType": platform.os_type(), "osVersion": platform.default_os_version(), "arch": platform.default_arch(), "terminal": "unknown" },
|
||||
"defaults": { "originator": configuration.default_originator(), "osType": platform.os_type(), "osVersion": platform.default_os_version(), "arch": platform.default_arch(), "terminal": baseline::TERMINAL },
|
||||
}));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -97,12 +97,14 @@ pub(in crate::transport::websocket) fn stream_websocket_response(
|
||||
pool_return,
|
||||
reused_connection,
|
||||
stream_idle_timeout,
|
||||
trace,
|
||||
shutdown,
|
||||
downstream_cancellation,
|
||||
delivery: WebSocketStreamDelivery {
|
||||
trace,
|
||||
shutdown,
|
||||
downstream_cancellation,
|
||||
tx,
|
||||
},
|
||||
rate_limit_updates: rate_limit_updates_for_task,
|
||||
response_metadata_updates: response_metadata_updates_for_task,
|
||||
tx,
|
||||
})
|
||||
.await;
|
||||
};
|
||||
@@ -133,33 +135,69 @@ pub(in crate::transport::websocket) fn stream_websocket_response(
|
||||
}
|
||||
|
||||
struct WebSocketStreamForwardState {
|
||||
trace: TraceContext,
|
||||
websocket: PumpedWebSocket,
|
||||
metadata: CodexWebSocketConnectionMetadata,
|
||||
pool_return: Option<WebSocketStreamPoolReturn>,
|
||||
reused_connection: bool,
|
||||
stream_idle_timeout: Option<Duration>,
|
||||
shutdown: CancellationToken,
|
||||
downstream_cancellation: Option<gateway_core::lifecycle::CancellationToken>,
|
||||
rate_limit_updates: CodexWebSocketRateLimitUpdates,
|
||||
response_metadata_updates: CodexWebSocketResponseMetadataUpdates,
|
||||
delivery: WebSocketStreamDelivery,
|
||||
}
|
||||
|
||||
struct WebSocketStreamDelivery {
|
||||
trace: TraceContext,
|
||||
shutdown: CancellationToken,
|
||||
downstream_cancellation: Option<gateway_core::lifecycle::CancellationToken>,
|
||||
tx: mpsc::Sender<Result<Bytes, CodexWebSocketExchangeError>>,
|
||||
}
|
||||
|
||||
impl WebSocketStreamDelivery {
|
||||
async fn cancelled(&self) -> StreamWebSocketDiscardReason {
|
||||
let (reason, discard_reason) = tokio::select! {
|
||||
biased;
|
||||
() = async {
|
||||
match &self.downstream_cancellation {
|
||||
Some(cancellation) => cancellation.cancelled().await,
|
||||
None => std::future::pending().await,
|
||||
}
|
||||
} => ("downstream_connection_closed", StreamWebSocketDiscardReason::ClientCancelled),
|
||||
() = self.tx.closed() => ("receiver_dropped", StreamWebSocketDiscardReason::ClientCancelled),
|
||||
() = self.shutdown.cancelled() => ("pool_shutdown", StreamWebSocketDiscardReason::PoolShutdown),
|
||||
};
|
||||
self.trace
|
||||
.record("upstream.cancelled", json!({"reason": reason}));
|
||||
discard_reason
|
||||
}
|
||||
|
||||
async fn send(
|
||||
&self,
|
||||
event: Result<Bytes, CodexWebSocketExchangeError>,
|
||||
) -> Result<(), StreamWebSocketDiscardReason> {
|
||||
// 终态与错误也可能被满队列阻塞,所有交付等待都必须响应取消和停机
|
||||
tokio::select! {
|
||||
biased;
|
||||
reason = self.cancelled() => Err(reason),
|
||||
result = self.tx.send(event) => result.map_err(|_| {
|
||||
self.trace.record("upstream.forward.failed", json!({"reason": "receiver_dropped"}));
|
||||
StreamWebSocketDiscardReason::DownstreamSendFailed
|
||||
}),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn forward_websocket_response_stream(state: WebSocketStreamForwardState) {
|
||||
let WebSocketStreamForwardState {
|
||||
trace,
|
||||
mut websocket,
|
||||
mut metadata,
|
||||
pool_return,
|
||||
reused_connection,
|
||||
stream_idle_timeout,
|
||||
shutdown,
|
||||
downstream_cancellation,
|
||||
rate_limit_updates,
|
||||
response_metadata_updates,
|
||||
tx,
|
||||
delivery,
|
||||
} = state;
|
||||
let trace = &delivery.trace;
|
||||
let mut pool_return = pool_return;
|
||||
let mut continuation = pool_return
|
||||
.as_mut()
|
||||
@@ -172,38 +210,8 @@ async fn forward_websocket_response_stream(state: WebSocketStreamForwardState) {
|
||||
loop {
|
||||
let message = tokio::select! {
|
||||
biased;
|
||||
() = async {
|
||||
match &downstream_cancellation {
|
||||
Some(cancellation) => cancellation.cancelled().await,
|
||||
None => std::future::pending().await,
|
||||
}
|
||||
} => {
|
||||
trace.record("upstream.cancelled", json!({"reason": "downstream_connection_closed"}));
|
||||
discard_stream_websocket(
|
||||
websocket,
|
||||
pool_return,
|
||||
StreamWebSocketDiscardReason::ClientCancelled,
|
||||
).await;
|
||||
return;
|
||||
}
|
||||
// 客户端断开下游 SSE 流:立即丢弃连接并释放池 slot,
|
||||
// 不再傻等上游 idle 超时(否则同会话后续请求会一直 bypass/busy)
|
||||
() = tx.closed() => {
|
||||
trace.record("upstream.cancelled", json!({"reason": "receiver_dropped"}));
|
||||
discard_stream_websocket(
|
||||
websocket,
|
||||
pool_return,
|
||||
StreamWebSocketDiscardReason::ClientCancelled,
|
||||
).await;
|
||||
return;
|
||||
}
|
||||
() = shutdown.cancelled() => {
|
||||
trace.record("upstream.cancelled", json!({"reason": "pool_shutdown"}));
|
||||
discard_stream_websocket(
|
||||
websocket,
|
||||
pool_return,
|
||||
StreamWebSocketDiscardReason::PoolShutdown,
|
||||
).await;
|
||||
reason = delivery.cancelled() => {
|
||||
discard_stream_websocket(websocket, pool_return, reason).await;
|
||||
return;
|
||||
}
|
||||
message = next_websocket_message(
|
||||
@@ -239,7 +247,7 @@ async fn forward_websocket_response_stream(state: WebSocketStreamForwardState) {
|
||||
} else {
|
||||
error
|
||||
};
|
||||
let _ = tx.send(Err(error)).await;
|
||||
let _ = delivery.send(Err(error)).await;
|
||||
return;
|
||||
}
|
||||
};
|
||||
@@ -258,7 +266,7 @@ async fn forward_websocket_response_stream(state: WebSocketStreamForwardState) {
|
||||
StreamWebSocketDiscardReason::UnexpectedBinaryEvent,
|
||||
)
|
||||
.await;
|
||||
let _ = tx
|
||||
let _ = delivery
|
||||
.send(Err(error.with_connection_observation(observation)))
|
||||
.await;
|
||||
return;
|
||||
@@ -293,7 +301,7 @@ async fn forward_websocket_response_stream(state: WebSocketStreamForwardState) {
|
||||
} else {
|
||||
error
|
||||
};
|
||||
let _ = tx.send(Err(error)).await;
|
||||
let _ = delivery.send(Err(error)).await;
|
||||
return;
|
||||
}
|
||||
_ => continue,
|
||||
@@ -315,7 +323,7 @@ async fn forward_websocket_response_stream(state: WebSocketStreamForwardState) {
|
||||
Some(observation) => error.with_connection_observation(observation),
|
||||
None => error,
|
||||
};
|
||||
let _ = tx.send(Err(error)).await;
|
||||
let _ = delivery.send(Err(error)).await;
|
||||
return;
|
||||
}
|
||||
};
|
||||
@@ -336,19 +344,6 @@ async fn forward_websocket_response_stream(state: WebSocketStreamForwardState) {
|
||||
ExchangeAction::Forward { terminal } => terminal,
|
||||
ExchangeAction::Ignore => continue,
|
||||
};
|
||||
if tx.send(Ok(Bytes::from(raw))).await.is_err() {
|
||||
trace.record(
|
||||
"upstream.forward.failed",
|
||||
json!({"reason": "receiver_dropped"}),
|
||||
);
|
||||
discard_stream_websocket(
|
||||
websocket,
|
||||
pool_return,
|
||||
StreamWebSocketDiscardReason::DownstreamSendFailed,
|
||||
)
|
||||
.await;
|
||||
return;
|
||||
}
|
||||
if let Some(terminal) = terminal {
|
||||
trace.record(
|
||||
"upstream.terminal",
|
||||
@@ -377,6 +372,12 @@ async fn forward_websocket_response_stream(state: WebSocketStreamForwardState) {
|
||||
.await;
|
||||
}
|
||||
}
|
||||
// 先归还续接状态或释放 socket,终态交付不能延迟资源收尾
|
||||
let _ = delivery.send(Ok(Bytes::from(raw))).await;
|
||||
return;
|
||||
}
|
||||
if let Err(reason) = delivery.send(Ok(Bytes::from(raw))).await {
|
||||
discard_stream_websocket(websocket, pool_return, reason).await;
|
||||
return;
|
||||
}
|
||||
}
|
||||
@@ -427,7 +428,7 @@ async fn forward_websocket_response_stream(state: WebSocketStreamForwardState) {
|
||||
} else {
|
||||
error
|
||||
};
|
||||
let _ = tx.send(Err(error)).await;
|
||||
let _ = delivery.send(Err(error)).await;
|
||||
}
|
||||
|
||||
async fn finish_stream_websocket(
|
||||
|
||||
@@ -293,10 +293,7 @@ async fn backend_http_should_preserve_business_headers_without_downstream_transp
|
||||
raw_header_values(&raw, "x-openai-account-routing-override"),
|
||||
vec![b"configured-route".to_vec()]
|
||||
);
|
||||
assert_eq!(
|
||||
raw_header_values(&raw, "x-codex-installation-id"),
|
||||
vec![b"lease-installation".to_vec()]
|
||||
);
|
||||
assert!(raw_header_values(&raw, "x-codex-installation-id").is_empty());
|
||||
let session = raw_header_values(&raw, "session-id");
|
||||
assert!(uuid::Uuid::parse_str(std::str::from_utf8(&session[0]).unwrap()).is_ok());
|
||||
// 指纹头由运行时画像生成,不透传客户端值
|
||||
@@ -486,10 +483,7 @@ async fn backend_websocket_should_preserve_business_headers_without_downstream_t
|
||||
values("x-openai-account-routing-override"),
|
||||
vec![b"configured-route".to_vec()]
|
||||
);
|
||||
assert_eq!(
|
||||
values("x-codex-installation-id"),
|
||||
vec![b"lease-installation".to_vec()]
|
||||
);
|
||||
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()]);
|
||||
|
||||
@@ -23,6 +23,82 @@ use crate::support::{MemoryAccountStore, catalog_cache, profile, secret};
|
||||
const OFFICIAL_FIXTURE: &[u8] =
|
||||
include_bytes!("../../transport/fixtures/official_models_snapshot.json");
|
||||
|
||||
#[tokio::test]
|
||||
async fn discovery_refresh_and_export_use_the_current_global_profile() {
|
||||
use gateway_core::account::OpaqueProviderData;
|
||||
use serde_json::json;
|
||||
|
||||
let document =
|
||||
|value: serde_json::Value| OpaqueProviderData::new(value.as_object().unwrap().clone());
|
||||
let fixed = |version| {
|
||||
document(
|
||||
json!({"client":"cli","platform":"macos","versionMode":"fixed","codexVersion":version}),
|
||||
)
|
||||
};
|
||||
let store = Arc::new(MemoryAccountStore::default());
|
||||
let first = seed_account(&store, "acct_profile_a").await;
|
||||
let second = seed_account(&store, "acct_profile_b").await;
|
||||
let server = MockServer::start().await;
|
||||
for (version, originator, count) in [
|
||||
("0.169.0", "codex_cli_rs", 2),
|
||||
("0.170.0", "codex_cli_rs", 1),
|
||||
("0.171.0", "catalog-test", 1),
|
||||
] {
|
||||
Mock::given(method("GET"))
|
||||
.and(path("/codex/models"))
|
||||
.and(query_param("client_version", version))
|
||||
.and(header("version", version))
|
||||
.and(header("originator", originator))
|
||||
.and(move |request: &Request| request.headers.get("user-agent").and_then(|v| v.to_str().ok()).is_some_and(|ua| ua.starts_with(&format!("{originator}/{version}"))))
|
||||
.respond_with(ResponseTemplate::new(200).set_body_json(json!({"models":[{"slug":format!("model-{version}"),"display_name":"Native","future_field":true}]})))
|
||||
.expect(count).mount(&server).await;
|
||||
}
|
||||
let policy = Arc::new(crate::support::RequestProfileRuntimePolicy(
|
||||
std::sync::Mutex::new(fixed("0.169.0")),
|
||||
));
|
||||
let baseline = wire_profile();
|
||||
let service = CodexCredentialCatalogService::new(
|
||||
store.repository(),
|
||||
baseline.clone(),
|
||||
reqwest::Client::builder().no_proxy().build().unwrap(),
|
||||
server.uri(),
|
||||
catalog_cache(),
|
||||
policy.clone(),
|
||||
);
|
||||
service.refresh_catalogs().await.unwrap();
|
||||
for account in [&first, &second] {
|
||||
assert_eq!(
|
||||
service.cached_account_models(account).unwrap().unwrap(),
|
||||
["model-0.169.0"]
|
||||
);
|
||||
}
|
||||
*policy.0.lock().unwrap() = fixed("0.170.0");
|
||||
assert_eq!(
|
||||
service
|
||||
.refresh_account_catalog(first.id())
|
||||
.await
|
||||
.unwrap()
|
||||
.models(),
|
||||
["model-0.170.0"]
|
||||
);
|
||||
*policy.0.lock().unwrap() = document(
|
||||
json!({"mode":"custom","userAgent":"catalog-test/0.171.0","originator":"catalog-test","codexVersion":"0.171.0"}),
|
||||
);
|
||||
let (models, _) = service.account_catalog_documents(&first).await.unwrap();
|
||||
assert_eq!(models[0].request_model().as_str(), "model-0.171.0");
|
||||
assert_eq!(baseline.snapshot().codex_version, "0.144.0");
|
||||
|
||||
*policy.0.lock().unwrap() = document(json!({"mode":"custom","userAgent":"invalid"}));
|
||||
assert!(matches!(
|
||||
service.refresh_account_catalog(first.id()).await,
|
||||
Err(CodexCredentialCatalogError::Profile(_))
|
||||
));
|
||||
assert_eq!(
|
||||
service.cached_account_models(&first).unwrap().unwrap(),
|
||||
["model-0.170.0"]
|
||||
);
|
||||
}
|
||||
|
||||
struct ReplacingCatalogResponder {
|
||||
calls: Arc<AtomicUsize>,
|
||||
}
|
||||
@@ -95,6 +171,7 @@ fn service_with_catalog_cache(
|
||||
.expect("client"),
|
||||
base_url,
|
||||
catalog_cache,
|
||||
crate::support::runtime_policy(),
|
||||
)
|
||||
}
|
||||
|
||||
|
||||
@@ -242,6 +242,7 @@ fn selector_with_runtime(
|
||||
http.clone(),
|
||||
OFFICIAL_CODEX_BASE_URL.to_owned(),
|
||||
crate::support::catalog_cache(),
|
||||
crate::support::runtime_policy(),
|
||||
),
|
||||
);
|
||||
let quota = Arc::new(CodexCredentialQuotaService::new(
|
||||
|
||||
@@ -218,6 +218,8 @@ async fn complete_with_name(
|
||||
|
||||
#[tokio::test]
|
||||
async fn authorize_url_matches_the_official_desktop_parameter_contract() {
|
||||
let wire_profile = profile();
|
||||
let desktop_version = wire_profile.snapshot().desktop_version;
|
||||
let service = CodexOAuthAdminService::new(
|
||||
Arc::new(PendingStore::default()),
|
||||
Arc::new(Exchanger {
|
||||
@@ -225,7 +227,7 @@ async fn authorize_url_matches_the_official_desktop_parameter_contract() {
|
||||
}),
|
||||
Arc::new(MemoryAccountStore::default()),
|
||||
CodexCredentialAdmin,
|
||||
profile(),
|
||||
wire_profile,
|
||||
);
|
||||
let started = service
|
||||
.start_authorization(StartCodexOAuthAuthorization {
|
||||
@@ -326,7 +328,7 @@ async fn authorize_url_matches_the_official_desktop_parameter_contract() {
|
||||
);
|
||||
assert_eq!(
|
||||
parameters.get("codex_app_version").map(String::as_str),
|
||||
Some("26.901.51231")
|
||||
Some(desktop_version.as_str())
|
||||
);
|
||||
let surface_stable_id = parameters
|
||||
.get("source_surface_stable_id")
|
||||
|
||||
@@ -192,7 +192,7 @@ async fn warmup_consumes_completed_sse_and_persists_rate_limit_event() {
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn warmup_sends_the_lowest_reasoning_effort_supported_by_the_catalog() {
|
||||
async fn warmup_uses_global_profile_and_lowest_reasoning_effort() {
|
||||
let server = MockServer::start().await;
|
||||
let sse = concat!(
|
||||
"event: response.completed\n",
|
||||
@@ -201,19 +201,27 @@ async fn warmup_sends_the_lowest_reasoning_effort_supported_by_the_catalog() {
|
||||
);
|
||||
Mock::given(method("POST"))
|
||||
.and(path("/codex/responses"))
|
||||
.and(wiremock::matchers::header("version", "0.169.0"))
|
||||
.and(wiremock::matchers::header("originator", "codex_cli_rs"))
|
||||
.respond_with(ResponseTemplate::new(200).set_body_raw(sse, "text/event-stream"))
|
||||
.expect(1)
|
||||
.mount(&server)
|
||||
.await;
|
||||
let store = Arc::new(MemoryAccountStore::default());
|
||||
create_account(&store, "acct_warmup_effort").await;
|
||||
let service = quota_service_with_base_url(
|
||||
&store,
|
||||
let policy = Arc::new(crate::support::RequestProfileRuntimePolicy(std::sync::Mutex::new(
|
||||
OpaqueProviderData::new(json!({"client":"cli","platform":"macos","versionMode":"fixed","codexVersion":"0.169.0"}).as_object().unwrap().clone()),
|
||||
)));
|
||||
let service = CodexCredentialQuotaService::new(
|
||||
store.repository(),
|
||||
wire_profile(),
|
||||
reqwest::Client::builder()
|
||||
.no_proxy()
|
||||
.build()
|
||||
.expect("client"),
|
||||
server.uri(),
|
||||
Arc::new(crate::support::MemoryCooldownPort::new()),
|
||||
policy.clone(),
|
||||
);
|
||||
|
||||
let summary = service.execute_warmup("test-model").await.expect("warmup");
|
||||
@@ -226,6 +234,16 @@ async fn warmup_sends_the_lowest_reasoning_effort_supported_by_the_catalog() {
|
||||
serde_json::from_slice(&decoded).expect("warmup body should be valid JSON");
|
||||
// 上游按目录拒绝目录外的档位,none 曾让全部定时预热只留下 error 终态
|
||||
assert_eq!(body["reasoning"]["effort"], "low");
|
||||
*policy.0.lock().unwrap() = OpaqueProviderData::new(
|
||||
json!({"mode":"custom","userAgent":"invalid"})
|
||||
.as_object()
|
||||
.unwrap()
|
||||
.clone(),
|
||||
);
|
||||
assert!(matches!(
|
||||
service.execute_warmup("test-model").await,
|
||||
Err(CodexCredentialQuotaError::Profile(_))
|
||||
));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
|
||||
@@ -13,6 +13,7 @@ fn cookie_provider(store: &Arc<MemoryAccountStore>, base_url: String) -> Arc<Cod
|
||||
http.clone(),
|
||||
base_url.clone(),
|
||||
catalog_cache(),
|
||||
crate::support::runtime_policy(),
|
||||
));
|
||||
let quota = Arc::new(CodexCredentialQuotaService::new(
|
||||
store.repository(),
|
||||
|
||||
@@ -2,16 +2,21 @@
|
||||
|
||||
use super::*;
|
||||
|
||||
fn metadata() -> Value {
|
||||
json!({"session_id":"source-session", "thread_id":"source-thread", "turn_id":"source-turn",
|
||||
"parent_thread_id":"source-session", "forked_from_thread_id":"source-session",
|
||||
const SESSION_ID: &str = "019b1234-5678-7abc-8def-0123456789ab";
|
||||
const THREAD_ID: &str = "019b1234-5679-7def-8abc-0123456789ab";
|
||||
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,
|
||||
"parent_turn_id":"source-turn", "root_turn_id":"source-turn",
|
||||
"window_id":"source-window", "context_window_id":"source-window", "future":{"keep":true},
|
||||
"window_id":format!("{THREAD_ID}:{window_number}"), "window_number":window_number,
|
||||
"context_window_id":CONTEXT_WINDOW_ID, "future":{"keep":true},
|
||||
"sentry-trace":"source-trace", "baggage":"sentry-environment=synthetic"})
|
||||
}
|
||||
|
||||
fn payload(websocket: bool) -> ProtocolPayload {
|
||||
let mut full = metadata();
|
||||
fn payload(websocket: bool, window_number: u64) -> ProtocolPayload {
|
||||
let mut full = metadata(window_number);
|
||||
full["tool_namespaces_info"] = json!({"inventory":"body-only"});
|
||||
let mut input = account_isolation::isolation_history()
|
||||
.as_array()
|
||||
@@ -31,17 +36,17 @@ fn payload(websocket: bool) -> ProtocolPayload {
|
||||
}
|
||||
input.insert(0, json!({"role":"user", "content":[{"type":"input_text", "text":concat!(
|
||||
"<external_codex_git_state><environment_context><git>",
|
||||
r#"{"sessionId":"source-session","threadId":"source-thread","clientUserMessageId":"source-turn","path":"/workspace/project"}"#,
|
||||
r#"{"sessionId":"019b1234-5678-7abc-8def-0123456789ab","threadId":"019b1234-5679-7def-8abc-0123456789ab","clientUserMessageId":"source-turn","path":"/workspace/project"}"#,
|
||||
"</git></environment_context></external_codex_git_state>"
|
||||
)}], "internal_chat_message_metadata_passthrough":{
|
||||
"turn_id":"source-turn", "content_item_kinds":["additional_content.codex_git_state"]
|
||||
}}));
|
||||
ProtocolPayload::json_object("openai", json!({
|
||||
"model":"gpt-5.4", "input":input,
|
||||
"prompt_cache_key":"custom-cache-key", "client_metadata":{
|
||||
"session_id":"source-session", "thread_id":"source-thread", "turn_id":"source-turn",
|
||||
"prompt_cache_key":SESSION_ID, "client_metadata":{
|
||||
"session_id":SESSION_ID, "thread_id":THREAD_ID, "turn_id":"source-turn",
|
||||
"x-client-turn-id":"source-turn",
|
||||
"x-codex-window-id":"source-window", "x-codex-parent-thread-id":"source-session",
|
||||
"x-codex-window-id":format!("{THREAD_ID}:{window_number}"), "x-codex-parent-thread-id":SESSION_ID,
|
||||
"x-codex-turn-metadata":full.to_string(),
|
||||
"ws_request_header_traceparent":"00-11111111111111111111111111111111-2222222222222222-01",
|
||||
"ws_request_header_tracestate":"vendor=source",
|
||||
@@ -50,9 +55,10 @@ fn payload(websocket: bool) -> ProtocolPayload {
|
||||
}
|
||||
}).as_object().unwrap().clone()).unwrap().with_context(Map::from_iter([
|
||||
("use_websocket".into(), json!(websocket)),
|
||||
("session_id".into(), json!("source-session")),
|
||||
("thread_id".into(), json!("source-thread")),
|
||||
("turn_metadata".into(), json!(metadata().to_string())),
|
||||
("session_id".into(), json!(SESSION_ID)),
|
||||
("thread_id".into(), json!(THREAD_ID)),
|
||||
("turn_metadata".into(), json!(metadata(window_number).to_string())),
|
||||
("codex_window_id".into(), json!(format!("{THREAD_ID}:{window_number}"))),
|
||||
("opaque_request_headers".into(), json!([
|
||||
["x-client-turn-id",STANDARD.encode("source-turn")],
|
||||
["traceparent",STANDARD.encode("00-11111111111111111111111111111111-2222222222222222-01")],
|
||||
@@ -74,7 +80,7 @@ async fn account_correlation_preserves_turns_across_transports_and_account_switc
|
||||
create_account(&stores[1], "acct_scope_new").await;
|
||||
let mut captures = Vec::new();
|
||||
for account in [0, 0, 1, 0] {
|
||||
for websocket in [false, true] {
|
||||
for (window_number, websocket) in [(0, false), (0, true), (1, false), (1, true)] {
|
||||
let (base_url, capture): (
|
||||
String,
|
||||
BoxFuture<'static, (reqwest::header::HeaderMap, Value)>,
|
||||
@@ -126,6 +132,7 @@ async fn account_correlation_preserves_turns_across_transports_and_account_switc
|
||||
"openai",
|
||||
Operation::Generate(GenerateRequest::from_protocol_payload(payload(
|
||||
websocket,
|
||||
window_number,
|
||||
))),
|
||||
),
|
||||
context("req_correlation", CancellationToken::new()),
|
||||
@@ -161,19 +168,18 @@ async fn account_correlation_preserves_turns_across_transports_and_account_switc
|
||||
flat["ws_request_header_baggage"],
|
||||
"sentry-environment=synthetic"
|
||||
);
|
||||
assert_eq!(
|
||||
headers["x-codex-installation-id"].to_str().unwrap(),
|
||||
flat["x-codex-installation-id"]
|
||||
);
|
||||
assert!(!headers.contains_key("x-codex-installation-id"));
|
||||
let header: Value =
|
||||
serde_json::from_str(headers["x-codex-turn-metadata"].to_str().unwrap()).unwrap();
|
||||
let full: Value =
|
||||
serde_json::from_str(flat["x-codex-turn-metadata"].as_str().unwrap()).unwrap();
|
||||
for (field, original) in [
|
||||
("session_id", "source-session"),
|
||||
("thread_id", "source-thread"),
|
||||
] {
|
||||
assert_scoped_id(flat[field].as_str().unwrap(), original);
|
||||
for (field, original) in [("session_id", SESSION_ID), ("thread_id", THREAD_ID)] {
|
||||
let mapped = flat[field].as_str().unwrap();
|
||||
assert_scoped_id(mapped, original);
|
||||
let mapped_uuid = uuid::Uuid::parse_str(mapped).unwrap();
|
||||
let original_uuid = uuid::Uuid::parse_str(original).unwrap();
|
||||
assert_eq!(mapped_uuid.get_version(), Some(uuid::Version::SortRand));
|
||||
assert_eq!(mapped_uuid.get_timestamp(), original_uuid.get_timestamp());
|
||||
assert_eq!(flat[field], header[field]);
|
||||
assert_eq!(flat[field], full[field]);
|
||||
}
|
||||
@@ -191,10 +197,26 @@ 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["window_id"], full["context_window_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);
|
||||
assert_eq!(flat["x-codex-window-id"], expected_window);
|
||||
assert_eq!(
|
||||
headers["x-client-request-id"].to_str().unwrap(),
|
||||
mapped_thread
|
||||
);
|
||||
for metadata in [&header, &full] {
|
||||
assert_eq!(metadata["window_id"], expected_window);
|
||||
assert_eq!(metadata["window_number"], window_number);
|
||||
assert_scoped_id(
|
||||
metadata["context_window_id"].as_str().unwrap(),
|
||||
CONTEXT_WINDOW_ID,
|
||||
);
|
||||
assert_ne!(metadata["context_window_id"], metadata["window_id"]);
|
||||
}
|
||||
assert!(header.get("tool_namespaces_info").is_none());
|
||||
assert_eq!(full["tool_namespaces_info"]["inventory"], "body-only");
|
||||
assert_eq!(full["future"], metadata()["future"]);
|
||||
assert_eq!(full["future"], metadata(window_number)["future"]);
|
||||
let input = body["input"].as_array().unwrap();
|
||||
assert_eq!(
|
||||
input[0]["internal_chat_message_metadata_passthrough"],
|
||||
@@ -242,10 +264,8 @@ async fn account_correlation_preserves_turns_across_transports_and_account_switc
|
||||
assert_eq!(git[desktop], flat[wire]);
|
||||
}
|
||||
assert_eq!(git["path"], "/workspace/project");
|
||||
assert_scoped_id(
|
||||
body["prompt_cache_key"].as_str().unwrap(),
|
||||
"custom-cache-key",
|
||||
);
|
||||
assert_scoped_id(body["prompt_cache_key"].as_str().unwrap(), SESSION_ID);
|
||||
assert_eq!(body["prompt_cache_key"], flat["session_id"]);
|
||||
captures.push((
|
||||
[
|
||||
flat["session_id"].clone(),
|
||||
@@ -257,13 +277,69 @@ async fn account_correlation_preserves_turns_across_transports_and_account_switc
|
||||
));
|
||||
}
|
||||
}
|
||||
for index in [1, 2, 3, 6, 7] {
|
||||
for index in [1, 2, 3, 4, 5, 6, 7, 12, 13, 14, 15] {
|
||||
assert_eq!(captures[0], captures[index]);
|
||||
}
|
||||
assert_eq!(captures[4], captures[5]);
|
||||
assert_ne!(captures[0].0, captures[4].0);
|
||||
assert_ne!(captures[0].1, captures[4].1);
|
||||
assert_eq!(captures[0].2, captures[4].2);
|
||||
for index in [9, 10, 11] {
|
||||
assert_eq!(captures[8], captures[index]);
|
||||
}
|
||||
assert_ne!(captures[0].0, captures[8].0);
|
||||
assert_ne!(captures[0].1, captures[8].1);
|
||||
assert_eq!(captures[0].2, captures[8].2);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn window_aliases_preserve_structure_without_reinterpreting_opaque_ids() {
|
||||
for (original, number) in [
|
||||
(format!("{THREAD_ID}:0"), Some(0)),
|
||||
(format!("{THREAD_ID}:1"), Some(1)),
|
||||
("custom-window".to_owned(), None),
|
||||
(format!("{THREAD_ID}:next"), None),
|
||||
] {
|
||||
let metadata = json!({
|
||||
"thread_id": THREAD_ID,
|
||||
"window_id": original,
|
||||
"codexWindowId": original,
|
||||
"x-codex-window-id": original,
|
||||
"context_window_id": original,
|
||||
});
|
||||
let request = capture_scoped_http_request(
|
||||
"req_window_aliases",
|
||||
"acct_scope_same",
|
||||
"acct_scope_same",
|
||||
json!({
|
||||
"model":"gpt-5.4", "input":[],
|
||||
"turnMetadata": metadata,
|
||||
"turn_metadata": metadata.to_string(),
|
||||
"client_metadata": metadata,
|
||||
})
|
||||
.as_object()
|
||||
.unwrap()
|
||||
.clone(),
|
||||
Map::new(),
|
||||
)
|
||||
.await;
|
||||
let body = captured_request_body(&request);
|
||||
let encoded: Value = serde_json::from_str(body["turn_metadata"].as_str().unwrap()).unwrap();
|
||||
for mapped in [&body["turnMetadata"], &encoded, &body["client_metadata"]] {
|
||||
let window = mapped["window_id"].as_str().unwrap();
|
||||
assert_eq!(mapped["codexWindowId"], window);
|
||||
assert_eq!(mapped["x-codex-window-id"], window);
|
||||
if let Some(number) = number {
|
||||
assert_eq!(
|
||||
window,
|
||||
format!("{}:{number}", mapped["thread_id"].as_str().unwrap())
|
||||
);
|
||||
assert_ne!(mapped["context_window_id"], window);
|
||||
} else {
|
||||
assert_scoped_id(window, &original);
|
||||
assert_eq!(mapped["context_window_id"], window);
|
||||
}
|
||||
let context =
|
||||
uuid::Uuid::parse_str(mapped["context_window_id"].as_str().unwrap()).unwrap();
|
||||
assert_eq!(context.get_version(), Some(uuid::Version::Random));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
@@ -285,7 +361,7 @@ async fn image_generation_and_edit_preserve_the_client_turn_identity() {
|
||||
.unwrap()
|
||||
.with_context(Map::from_iter([
|
||||
("image_turn_id".into(), json!("source-turn")),
|
||||
("turn_metadata".into(), json!(metadata().to_string())),
|
||||
("turn_metadata".into(), json!(metadata(0).to_string())),
|
||||
])),
|
||||
));
|
||||
let mut stream = provider
|
||||
|
||||
@@ -0,0 +1,284 @@
|
||||
//! Messages 会话在原生与 Responses 上游的选号、隔离和最终身份复验
|
||||
|
||||
use super::*;
|
||||
use gateway_core::account::AccountAffinity;
|
||||
|
||||
const SESSION: &str = "12345678-1234-1234-1234-123456789abc";
|
||||
|
||||
fn operation(header: Option<&str>, user_id: Value) -> Operation {
|
||||
let body = json!({"model":"gpt-5.4", "max_tokens":128, "stream":true,
|
||||
"metadata":{"user_id":user_id}, "messages":[{"role":"user","content":"hello"}]});
|
||||
let mut context = Map::new();
|
||||
if let Some(header) = header {
|
||||
context.insert(
|
||||
"opaque_request_headers".to_owned(),
|
||||
json!([["x-claude-code-session-id", STANDARD.encode(header)]]),
|
||||
);
|
||||
}
|
||||
Operation::Generate(GenerateRequest::from_protocol_payload(
|
||||
ProtocolPayload::json_object("anthropic", body.as_object().unwrap().clone())
|
||||
.unwrap()
|
||||
.with_context(context),
|
||||
))
|
||||
}
|
||||
|
||||
fn attempt(client: &str) -> AttemptContext {
|
||||
AttemptContext::new(
|
||||
RequestAttemptContext::new(
|
||||
ModelRequestId::new("req_messages_affinity").unwrap(),
|
||||
ClientApiKeyId::new(client).unwrap(),
|
||||
),
|
||||
NonZeroU32::MIN,
|
||||
SystemTime::now() + Duration::from_secs(5),
|
||||
account_policy()
|
||||
.with_openai_account_affinity(AccountAffinity::Strict)
|
||||
.with_queue(gateway_core::concurrency::ConcurrencyQueuePolicy {
|
||||
max_waiting: 1,
|
||||
timeout: Duration::from_secs(2),
|
||||
}),
|
||||
AccountAttemptContext::new(BTreeSet::new(), None, None)
|
||||
.with_account_scope(contract_account_scope()),
|
||||
None,
|
||||
CancellationToken::new(),
|
||||
)
|
||||
}
|
||||
|
||||
async fn fixture(
|
||||
native_messages: bool,
|
||||
) -> (
|
||||
MockServer,
|
||||
Arc<CodexProvider>,
|
||||
Arc<MemorySessionAffinity>,
|
||||
Arc<TestLeaseCoordinator>,
|
||||
) {
|
||||
let server = MockServer::start().await;
|
||||
Mock::given(method("POST"))
|
||||
.and(path(if native_messages {
|
||||
"/messages"
|
||||
} else {
|
||||
"/codex/responses"
|
||||
}))
|
||||
.respond_with(ResponseTemplate::new(200).set_body_raw(
|
||||
if native_messages {
|
||||
MESSAGES_SSE
|
||||
} else {
|
||||
CAPTURE_COMPLETED_SSE
|
||||
},
|
||||
"text/event-stream",
|
||||
))
|
||||
.mount(&server)
|
||||
.await;
|
||||
let store = Arc::new(MemoryAccountStore::default());
|
||||
for id in ["acct_affinity_switch_a", "acct_affinity_switch_b"] {
|
||||
if native_messages {
|
||||
store
|
||||
.seed_api_key_for_protocol(
|
||||
id,
|
||||
server.uri(),
|
||||
ResponsesTransport::Http,
|
||||
ApiKeyProtocol::Messages,
|
||||
)
|
||||
.await;
|
||||
} else {
|
||||
create_account(&store, id).await;
|
||||
store.set_oauth_transport(id, ResponsesTransport::Http);
|
||||
}
|
||||
}
|
||||
let affinity = Arc::new(MemorySessionAffinity::default());
|
||||
let leases = Arc::new(TestLeaseCoordinator::default());
|
||||
let provider = provider_with_affinity_and_base_url_and_leases(
|
||||
&store,
|
||||
affinity.clone(),
|
||||
server.uri(),
|
||||
leases.clone(),
|
||||
);
|
||||
(server, provider, affinity, leases)
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn claude_sessions_keep_accounts_across_identity_formats_and_isolate_client_keys() {
|
||||
for native_messages in [false, true] {
|
||||
let (server, provider, affinity, _) = fixture(native_messages).await;
|
||||
let mut selected = Vec::new();
|
||||
let mut keys = Vec::new();
|
||||
for (client, header, user_id) in [
|
||||
(
|
||||
"key_openai_contract",
|
||||
Some(SESSION),
|
||||
json!("{\"session_id\":\"ignored-body-session\"}"),
|
||||
),
|
||||
(
|
||||
"key_openai_contract",
|
||||
None,
|
||||
json!(json!({"session_id":SESSION}).to_string()),
|
||||
),
|
||||
(
|
||||
"key_openai_contract",
|
||||
None,
|
||||
json!(format!("user_device_account__session_{SESSION}")),
|
||||
),
|
||||
("different-client", Some(SESSION), json!("ordinary-user")),
|
||||
(
|
||||
"key_openai_contract",
|
||||
Some("different-session"),
|
||||
json!("ordinary-user"),
|
||||
),
|
||||
] {
|
||||
let before = affinity.lookup_keys().len();
|
||||
let mut stream = provider
|
||||
.clone()
|
||||
.execute(
|
||||
planned_request("openai", operation(header, user_id)),
|
||||
attempt(client),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
selected.push(stream.metadata().provider_account_id().clone());
|
||||
keys.push(affinity.lookup_keys()[before].clone());
|
||||
while let Some(event) = stream.next().await {
|
||||
event.unwrap();
|
||||
}
|
||||
}
|
||||
assert!(selected[..3].iter().all(|account| account == &selected[0]));
|
||||
assert!(keys[..3].iter().all(|key| key == &keys[0]));
|
||||
assert_ne!(keys[3], keys[0]);
|
||||
assert_ne!(keys[4], keys[0]);
|
||||
assert_eq!(affinity.binding_count(), 3);
|
||||
assert!(
|
||||
affinity.alias_ttls().is_empty(),
|
||||
"Claude sessions must not create OpenAI turn aliases"
|
||||
);
|
||||
|
||||
let before = affinity.lookup_keys().len();
|
||||
drop(
|
||||
provider
|
||||
.clone()
|
||||
.execute(
|
||||
planned_request("openai", operation(None, json!("ordinary-user"))),
|
||||
attempt("key_openai_contract"),
|
||||
)
|
||||
.await
|
||||
.unwrap(),
|
||||
);
|
||||
assert_eq!(
|
||||
affinity.lookup_keys().len(),
|
||||
before,
|
||||
"ordinary users and message text do not identify sessions"
|
||||
);
|
||||
assert_eq!(server.received_requests().await.unwrap().len(), 5);
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn messages_strict_affinity_does_not_send_to_an_idle_alternate_when_bound_account_is_busy() {
|
||||
let (server, provider, affinity, leases) = fixture(false).await;
|
||||
let request = || planned_request("openai", operation(Some(SESSION), json!("user")));
|
||||
let first = provider
|
||||
.clone()
|
||||
.execute(request(), attempt("key_openai_contract"))
|
||||
.await
|
||||
.unwrap();
|
||||
let bound = first.metadata().provider_account_id().clone();
|
||||
drop(first);
|
||||
leases.busy_accounts.lock().unwrap().insert(bound.clone());
|
||||
let context = attempt("key_openai_contract");
|
||||
let cancellation = context.cancellation().clone();
|
||||
let pending = tokio::spawn(provider.execute(request(), context));
|
||||
tokio::time::timeout(Duration::from_secs(1), async {
|
||||
while leases.requests.lock().unwrap().len() < 2 {
|
||||
tokio::task::yield_now().await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
cancellation.cancel();
|
||||
assert!(pending.await.unwrap().is_err());
|
||||
assert!(
|
||||
leases
|
||||
.requests
|
||||
.lock()
|
||||
.unwrap()
|
||||
.iter()
|
||||
.all(|request| request.account_id() == &bound)
|
||||
);
|
||||
assert_eq!(affinity.binding_count(), 1);
|
||||
assert!(server.received_requests().await.unwrap().is_empty());
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
struct ChangeClaudeSession;
|
||||
|
||||
impl MiddlewarePlan for ChangeClaudeSession {
|
||||
fn handle(
|
||||
&self,
|
||||
_: MiddlewareContext,
|
||||
request: MiddlewareRequest,
|
||||
next: MiddlewareNext,
|
||||
) -> BoxFuture<'static, Result<MiddlewareResponse, MiddlewareError>> {
|
||||
Box::pin(async move {
|
||||
let protocol = request.protocol().to_owned();
|
||||
let body = request.body().clone();
|
||||
let mut headers = request.headers().to_vec();
|
||||
headers.push(MiddlewareHeader::new(
|
||||
"x-claude-code-session-id",
|
||||
Bytes::from_static(b"other-session"),
|
||||
));
|
||||
next.run(request.replace_parts(protocol, headers, body, None)?)
|
||||
.await
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn rewritten_claude_session_cannot_bypass_another_accounts_binding() {
|
||||
for native_messages in [false, true] {
|
||||
let (server, provider, affinity, _) = fixture(native_messages).await;
|
||||
drop(
|
||||
provider
|
||||
.clone()
|
||||
.execute(
|
||||
planned_request("openai", operation(Some(SESSION), json!("user"))),
|
||||
attempt("key_openai_contract"),
|
||||
)
|
||||
.await
|
||||
.unwrap(),
|
||||
);
|
||||
let key = affinity.lookup_keys()[0].clone();
|
||||
affinity.seed_binding(
|
||||
&ProviderKind::new("openai").unwrap(),
|
||||
&key,
|
||||
ProviderAccountId::new("acct_affinity_switch_a").unwrap(),
|
||||
);
|
||||
drop(
|
||||
provider
|
||||
.clone()
|
||||
.execute(
|
||||
planned_request("openai", operation(Some("other-session"), json!("user"))),
|
||||
attempt("key_openai_contract"),
|
||||
)
|
||||
.await
|
||||
.unwrap(),
|
||||
);
|
||||
let other = affinity.lookup_keys().last().unwrap().clone();
|
||||
affinity.seed_binding(
|
||||
&ProviderKind::new("openai").unwrap(),
|
||||
&other,
|
||||
ProviderAccountId::new("acct_affinity_switch_b").unwrap(),
|
||||
);
|
||||
let result = provider
|
||||
.execute(
|
||||
planned_request("openai", operation(Some(SESSION), json!("user"))),
|
||||
context_with_middleware(
|
||||
"req_rewritten_claude_session",
|
||||
Arc::new(ChangeClaudeSession),
|
||||
FastMode::Default,
|
||||
),
|
||||
)
|
||||
.await;
|
||||
let error = result
|
||||
.err()
|
||||
.expect("conflicting final identity must fail before sending");
|
||||
assert_eq!(error.send_state(), UpstreamSendState::NotSent);
|
||||
assert!(server.received_requests().await.unwrap().is_empty());
|
||||
}
|
||||
}
|
||||
+2
@@ -1,5 +1,7 @@
|
||||
//! Messages 原生 wire、跨协议头隔离和本地计数合同
|
||||
|
||||
mod affinity;
|
||||
|
||||
use super::*;
|
||||
use gateway_core::event::ProviderResponseTimings;
|
||||
use gateway_core::operation::TokenCountRequest;
|
||||
@@ -1284,6 +1284,7 @@ fn provider_and_quota_with_runtime_ports(
|
||||
http.clone(),
|
||||
base_url.clone(),
|
||||
catalog_cache(),
|
||||
crate::support::runtime_policy(),
|
||||
));
|
||||
let quota = Arc::new(CodexCredentialQuotaService::new(
|
||||
store.repository(),
|
||||
@@ -6326,8 +6327,10 @@ async fn installation_seed_scopes_http_identity_and_cache_by_key_and_account() {
|
||||
.iter()
|
||||
.zip(&bodies)
|
||||
.map(|(request, body)| {
|
||||
let id = request.headers["x-codex-installation-id"].to_str().unwrap();
|
||||
assert_eq!(id, body["client_metadata"]["x-codex-installation-id"]);
|
||||
let id = body["client_metadata"]["x-codex-installation-id"]
|
||||
.as_str()
|
||||
.unwrap();
|
||||
assert!(!request.headers.contains_key("x-codex-installation-id"));
|
||||
assert!(uuid::Uuid::parse_str(id).is_ok());
|
||||
assert_ne!(id, KEY_INSTALLATION_SEED);
|
||||
assert_ne!(id, other_seed);
|
||||
@@ -6359,7 +6362,7 @@ async fn installation_seed_scopes_http_identity_and_cache_by_key_and_account() {
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn http_account_scoping_replaces_downstream_installation_header() {
|
||||
async fn http_account_scoping_keeps_installation_in_metadata() {
|
||||
for owner in ["acct_scope_same", "acct_scope_old"] {
|
||||
let raw = r#"{"installation_id":"client-installation","future":true}"#;
|
||||
let request = capture_scoped_http_request(
|
||||
@@ -6400,10 +6403,7 @@ async fn http_account_scoping_replaces_downstream_installation_header() {
|
||||
assert_ne!(installation_id, "client-installation");
|
||||
assert!(uuid::Uuid::parse_str(installation_id).is_ok());
|
||||
assert_eq!(body["installation_id"], installation_id);
|
||||
assert_eq!(
|
||||
captured_header_values(&request, "x-codex-installation-id"),
|
||||
vec![installation_id.as_bytes().to_vec()]
|
||||
);
|
||||
assert!(captured_header_values(&request, "x-codex-installation-id").is_empty());
|
||||
let headers = captured_header_values(&request, "x-codex-turn-metadata");
|
||||
assert_eq!(headers.len(), 1);
|
||||
for encoded in [
|
||||
@@ -6421,7 +6421,7 @@ async fn http_account_scoping_replaces_downstream_installation_header() {
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn websocket_account_scoping_replaces_downstream_installation_header() {
|
||||
async fn websocket_account_scoping_keeps_installation_in_metadata() {
|
||||
for owner in ["acct_scope_same", "acct_scope_old"] {
|
||||
let raw = r#"{"installation_id":"client-installation","future":true}"#;
|
||||
let store = Arc::new(MemoryAccountStore::default());
|
||||
@@ -6510,7 +6510,7 @@ async fn websocket_account_scoping_replaces_downstream_installation_header() {
|
||||
assert_ne!(installation_id, KEY_INSTALLATION_SEED);
|
||||
assert!(uuid::Uuid::parse_str(installation_id).is_ok());
|
||||
assert_eq!(body["installation_id"], installation_id);
|
||||
assert_eq!(header["x-codex-installation-id"], installation_id);
|
||||
assert!(!header.contains_key("x-codex-installation-id"));
|
||||
for encoded in [
|
||||
header["x-codex-turn-metadata"]
|
||||
.to_str()
|
||||
@@ -6582,10 +6582,7 @@ async fn same_account_scope_preserves_future_protocol_shapes() {
|
||||
body.pointer("/client_metadata/x-codex-installation-id")
|
||||
);
|
||||
assert!(body.pointer("/client_metadata/installation_id").is_none());
|
||||
assert_eq!(
|
||||
request.headers["x-codex-installation-id"].to_str().unwrap(),
|
||||
body["client_metadata"]["x-codex-installation-id"]
|
||||
);
|
||||
assert!(!request.headers.contains_key("x-codex-installation-id"));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
|
||||
+46
-34
@@ -222,15 +222,23 @@ async fn account_allowlists_override_catalog_omissions_but_weight_affinity_and_p
|
||||
store.set_scheduling("acct_scope_new", None, AccountWeight::new(100).unwrap());
|
||||
let affinity = Arc::new(MemorySessionAffinity::default());
|
||||
let leases = Arc::new(TestLeaseCoordinator::default());
|
||||
let (provider, _) = provider_and_quota_with_catalog(
|
||||
let (provider, _, _, catalog) = provider_and_quota_with_runtime_ports(
|
||||
&store,
|
||||
affinity.clone(),
|
||||
native.uri(),
|
||||
leases.clone(),
|
||||
u32::try_from(DEFAULT_STREAM_MAX_RETRIES).unwrap(),
|
||||
)
|
||||
.await;
|
||||
Arc::new(MemoryCooldownPort::new()),
|
||||
crate::support::runtime_policy(),
|
||||
);
|
||||
catalog.refresh_catalogs().await.unwrap();
|
||||
provider.query_model_capabilities().await.unwrap();
|
||||
// 次账号目录待刷新时,仍须按各自的目录和白名单选号
|
||||
assert!(
|
||||
catalog
|
||||
.observe_response_etag(&store.account("acct_scope_new").unwrap(), "new")
|
||||
.unwrap()
|
||||
);
|
||||
for (model, expected) in [
|
||||
("gpt-6-luna", "acct_scope_new"),
|
||||
("gpt-6-astra", "acct_provider_contract"),
|
||||
@@ -364,7 +372,7 @@ async fn account_allowlists_override_catalog_omissions_but_weight_affinity_and_p
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn only_a_current_account_catalog_can_exclude_a_model() {
|
||||
async fn selection_uses_the_last_catalog_for_the_same_account_identity() {
|
||||
use gateway_core::account::{CredentialCasOutcome, CredentialCasUpdate, ProviderAccountUpdate};
|
||||
use provider_openai::credential::ResponsesTransport;
|
||||
|
||||
@@ -423,7 +431,16 @@ async fn only_a_current_account_catalog_can_exclude_a_model() {
|
||||
.expect(if scenario == "unknown_plan" { 0 } else { 1 })
|
||||
.mount(upstream)
|
||||
.await;
|
||||
let provider = if scenario == "expired" {
|
||||
let (provider, _, _, catalog) = provider_and_quota_with_runtime_ports(
|
||||
&store,
|
||||
Arc::new(MemorySessionAffinity::default()),
|
||||
native.uri(),
|
||||
Arc::new(TestLeaseCoordinator::default()),
|
||||
u32::try_from(DEFAULT_STREAM_MAX_RETRIES).unwrap(),
|
||||
Arc::new(MemoryCooldownPort::new()),
|
||||
crate::support::runtime_policy(),
|
||||
);
|
||||
if scenario == "expired" {
|
||||
use gateway_core::account::AccountCatalogObservation;
|
||||
let a = store.account("acct_scope_new").unwrap();
|
||||
store
|
||||
@@ -439,26 +456,8 @@ async fn only_a_current_account_catalog_can_exclude_a_model() {
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let (provider, _, _, catalog) = provider_and_quota_with_runtime_ports(
|
||||
&store,
|
||||
Arc::new(MemorySessionAffinity::default()),
|
||||
native.uri(),
|
||||
Arc::new(TestLeaseCoordinator::default()),
|
||||
u32::try_from(DEFAULT_STREAM_MAX_RETRIES).unwrap(),
|
||||
Arc::new(MemoryCooldownPort::new()),
|
||||
crate::support::runtime_policy(),
|
||||
);
|
||||
catalog.restore().await.unwrap();
|
||||
// B 的失败不能清空上次成功结果,也不能继续以旧的缺失条目拒绝请求
|
||||
catalog.refresh_catalogs().await.unwrap();
|
||||
assert_eq!(
|
||||
catalog.cached_account_models(&a).unwrap().unwrap(),
|
||||
["gpt-6-luna"]
|
||||
);
|
||||
provider
|
||||
} else {
|
||||
provider_with_catalog_and_base_url(&store, native.uri()).await
|
||||
};
|
||||
}
|
||||
catalog.refresh_catalogs().await.unwrap();
|
||||
provider.query_model_capabilities().await.unwrap();
|
||||
if scenario == "rotated" {
|
||||
let account = store.account("acct_scope_new").unwrap();
|
||||
@@ -483,21 +482,34 @@ async fn only_a_current_account_catalog_can_exclude_a_model() {
|
||||
CredentialCasOutcome::Updated(_)
|
||||
));
|
||||
}
|
||||
let result = provider
|
||||
.execute(
|
||||
let execute = || {
|
||||
provider.clone().execute(
|
||||
planned_request_for_model("openai", operation("gpt-6-astra"), "gpt-6-astra"),
|
||||
context("req_unknown_catalog", CancellationToken::new()),
|
||||
)
|
||||
.await;
|
||||
if scenario == "unknown_plan" {
|
||||
// 未知套餐也有该账号亲自返回的目录,不能借套餐缺失绕过资格
|
||||
};
|
||||
if matches!(scenario, "unknown_plan" | "expired") {
|
||||
assert_eq!(
|
||||
result.err().unwrap().kind(),
|
||||
ProviderErrorKind::NoEligibleAccount
|
||||
execute().await.err().unwrap().kind(),
|
||||
ProviderErrorKind::NoEligibleAccount,
|
||||
"{scenario}"
|
||||
);
|
||||
continue;
|
||||
if scenario == "unknown_plan" {
|
||||
continue;
|
||||
}
|
||||
// 刷新失败保留排除结果,直到新目录确认该账号已支持模型
|
||||
Mock::given(method("GET"))
|
||||
.and(path("/models"))
|
||||
.respond_with(ResponseTemplate::new(200).set_body_json(json!({
|
||||
"data": [{"id": "gpt-6-astra"}]
|
||||
})))
|
||||
.with_priority(1)
|
||||
.expect(1)
|
||||
.mount(&api)
|
||||
.await;
|
||||
catalog.refresh_catalogs().await.unwrap();
|
||||
}
|
||||
let mut stream = result.unwrap();
|
||||
let mut stream = execute().await.unwrap();
|
||||
assert_eq!(
|
||||
stream.metadata().provider_account_id().as_str(),
|
||||
"acct_scope_new",
|
||||
|
||||
@@ -1365,6 +1365,39 @@ pub(crate) fn profile(account_id: &str) -> CodexAccountProfile {
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) struct RequestProfileRuntimePolicy(
|
||||
pub(crate) std::sync::Mutex<gateway_core::account::OpaqueProviderData>,
|
||||
);
|
||||
|
||||
impl gateway_core::provider_ports::ProviderRuntimePolicyPort for RequestProfileRuntimePolicy {
|
||||
fn load_request_profile<'a>(
|
||||
&'a self,
|
||||
provider: &'a ProviderKind,
|
||||
) -> futures::future::BoxFuture<
|
||||
'a,
|
||||
Result<
|
||||
Option<gateway_core::account::OpaqueProviderData>,
|
||||
gateway_core::provider_ports::ProviderStoreError,
|
||||
>,
|
||||
> {
|
||||
assert_eq!(provider.as_str(), "openai");
|
||||
let profile = self.0.lock().unwrap().clone();
|
||||
Box::pin(async move { Ok(Some(profile)) })
|
||||
}
|
||||
|
||||
fn load_refresh_policy(
|
||||
&self,
|
||||
) -> futures::future::BoxFuture<
|
||||
'_,
|
||||
Result<
|
||||
gateway_core::provider_ports::ProviderRefreshPolicy,
|
||||
gateway_core::provider_ports::ProviderStoreError,
|
||||
>,
|
||||
> {
|
||||
Box::pin(async { crate::support::runtime_policy().load_refresh_policy().await })
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) struct StaticRuntimePolicy;
|
||||
|
||||
impl ProviderRuntimePolicyPort for StaticRuntimePolicy {
|
||||
|
||||
@@ -226,7 +226,6 @@ async fn backend_websocket_should_forward_context_headers_and_preserve_payload_f
|
||||
("x-codex-parent-thread-id", "parent-456"),
|
||||
("x-openai-subagent", "future_codex_mode"),
|
||||
("x-openai-memgen-request", "true"),
|
||||
("x-codex-installation-id", "install-123"),
|
||||
("session-id", "cp_derived"),
|
||||
] {
|
||||
let value = &headers.iter().find(|(header, _)| header == name).unwrap().1;
|
||||
@@ -241,6 +240,7 @@ async fn backend_websocket_should_forward_context_headers_and_preserve_payload_f
|
||||
}
|
||||
}
|
||||
for forbidden in [
|
||||
"x-codex-installation-id",
|
||||
"x-codex-turn-id",
|
||||
"x-openai-internal-codex-residency",
|
||||
"accept",
|
||||
@@ -303,7 +303,7 @@ async fn backend_http_should_send_codex_context_without_browser_headers() {
|
||||
codex_window_id: request.codex_window_id.as_deref(),
|
||||
parent_thread_id: request.parent_thread_id.as_deref(),
|
||||
cookie_header: Some("cf_clearance=old"),
|
||||
installation_id: Some("install-1"),
|
||||
installation_id: Some("3b11bc82-c666-417d-b9ff-2a34fd040385"),
|
||||
session_id: Some("session-1"),
|
||||
thread_id: None,
|
||||
client_request_id: None,
|
||||
@@ -345,7 +345,7 @@ async fn backend_http_should_send_codex_context_without_browser_headers() {
|
||||
let scoped_session = read_header_value(&raw_request, "session-id").unwrap();
|
||||
assert_ne!(scoped_session, "session-1");
|
||||
assert!(uuid::Uuid::parse_str(scoped_session).is_ok());
|
||||
for required in [
|
||||
let mut expected_names = vec![
|
||||
"authorization",
|
||||
"chatgpt-account-id",
|
||||
"originator",
|
||||
@@ -362,14 +362,17 @@ async fn backend_http_should_send_codex_context_without_browser_headers() {
|
||||
"x-responsesapi-include-timing-metrics",
|
||||
"version",
|
||||
"x-codex-parent-thread-id",
|
||||
] {
|
||||
assert!(header_names.iter().any(|name| name == required));
|
||||
}
|
||||
assert_eq!(
|
||||
read_header_value(&raw_request, "x-codex-installation-id"),
|
||||
Some("install-1")
|
||||
);
|
||||
"x-codex-routing-hint",
|
||||
"content-encoding",
|
||||
"content-length",
|
||||
"host",
|
||||
];
|
||||
let mut header_names = header_names;
|
||||
expected_names.sort_unstable();
|
||||
header_names.sort_unstable();
|
||||
assert_eq!(header_names, expected_names);
|
||||
for forbidden in [
|
||||
"x-codex-installation-id",
|
||||
"x-codex-turn-id",
|
||||
"x-openai-internal-codex-residency",
|
||||
"sec-ch-ua",
|
||||
|
||||
@@ -64,6 +64,11 @@ async fn official_cli_cache_updates_entry_headers_together_and_preserves_frozen_
|
||||
..Default::default()
|
||||
};
|
||||
let frozen = automatic.resolve(&state).unwrap();
|
||||
// 从当前基线构造后继发布,升级离线版本无需重写缓存更新场景
|
||||
let mut next = semver::Version::parse(&frozen.codex_version).unwrap();
|
||||
next.patch += 1;
|
||||
let next_sequence = 1 + next.major * 1_000_000 + next.minor * 1_000 + next.patch;
|
||||
let next_version = next.to_string();
|
||||
let fixed = ClientProfileSelection {
|
||||
version_mode: VersionMode::Fixed,
|
||||
codex_version: Some(frozen.codex_version.clone()),
|
||||
@@ -77,15 +82,17 @@ async fn official_cli_cache_updates_entry_headers_together_and_preserves_frozen_
|
||||
))
|
||||
.unwrap();
|
||||
|
||||
// 复用官方版本服务的恢复入口,模拟每日检查已核验并写入的下一份发布资料
|
||||
// 复用官方版本服务的恢复入口,模拟版本检查已核验并写入的下一份发布资料
|
||||
cache
|
||||
.replace_if_newer(
|
||||
ProviderArtifactProfile::new(
|
||||
provider.clone(),
|
||||
"cli-linux-x64".into(),
|
||||
157_001,
|
||||
next_sequence,
|
||||
chrono::Utc::now().into(),
|
||||
OpaqueProviderData::new(json!({"version":"0.157.0"}).as_object().unwrap().clone()),
|
||||
OpaqueProviderData::new(
|
||||
json!({"version":next_version}).as_object().unwrap().clone(),
|
||||
),
|
||||
),
|
||||
Duration::from_secs(86400),
|
||||
)
|
||||
@@ -100,11 +107,11 @@ async fn official_cli_cache_updates_entry_headers_together_and_preserves_frozen_
|
||||
let current = selection.resolve(&state).unwrap();
|
||||
let headers = build_codex_model_headers(¤t, "Bearer fixture", None).unwrap();
|
||||
let expected = format!(
|
||||
"{originator}/0.157.0 (Alpine Linux 3.24.1; x86_64) xterm-256color ({originator}; 0.157.0)"
|
||||
"{originator}/{next_version} (Alpine Linux 3.24.1; x86_64) xterm-256color ({originator}; {next_version})"
|
||||
);
|
||||
assert_eq!(headers["user-agent"], expected);
|
||||
assert_eq!(headers["originator"], originator);
|
||||
assert_eq!(headers["version"], "0.157.0");
|
||||
assert_eq!(headers["version"], next_version.as_str());
|
||||
}
|
||||
assert_eq!(
|
||||
fixed.resolve(&state).unwrap().user_agent(),
|
||||
@@ -114,7 +121,6 @@ async fn official_cli_cache_updates_entry_headers_together_and_preserves_frozen_
|
||||
custom.resolve(&state).unwrap().user_agent(),
|
||||
frozen.user_agent()
|
||||
);
|
||||
assert_eq!(frozen.codex_version, "0.155.0");
|
||||
|
||||
// 缓存恢复与启动种子构成观察历史,滞后档位据此钉住上一版。
|
||||
let lagged = ClientProfileSelection {
|
||||
@@ -123,7 +129,7 @@ async fn official_cli_cache_updates_entry_headers_together_and_preserves_frozen_
|
||||
};
|
||||
assert_eq!(
|
||||
lagged.resolve(&state).unwrap().user_agent(),
|
||||
"codex-tui/0.155.0 (Alpine Linux 3.24.1; x86_64) xterm-256color (codex-tui; 0.155.0)"
|
||||
frozen.user_agent()
|
||||
);
|
||||
|
||||
let restarted = CodexWireProfileState::new(super::wire_profile());
|
||||
@@ -136,3 +142,178 @@ async fn official_cli_cache_updates_entry_headers_together_and_preserves_frozen_
|
||||
automatic.resolve(&state).unwrap()
|
||||
);
|
||||
}
|
||||
|
||||
struct CliTransport {
|
||||
version: std::sync::Mutex<String>,
|
||||
}
|
||||
|
||||
impl provider_openai::transport::profile::cli_release::CliReleaseTransport for CliTransport {
|
||||
fn fetch(
|
||||
&self,
|
||||
) -> futures::future::BoxFuture<
|
||||
'_,
|
||||
Result<String, provider_openai::transport::profile::cli_release::CliReleaseError>,
|
||||
> {
|
||||
Box::pin(async move { Ok(self.version.lock().unwrap().clone()) })
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct CliCache {
|
||||
writes: std::sync::Mutex<std::collections::BTreeMap<String, usize>>,
|
||||
failing_target: std::sync::Mutex<Option<String>>,
|
||||
}
|
||||
|
||||
impl gateway_core::provider_ports::ProviderArtifactProfileCachePort for CliCache {
|
||||
fn replace_if_newer(
|
||||
&self,
|
||||
profile: gateway_core::provider_ports::ProviderArtifactProfile,
|
||||
_ttl: std::time::Duration,
|
||||
) -> futures::future::BoxFuture<
|
||||
'_,
|
||||
Result<bool, gateway_core::provider_ports::ProviderStoreError>,
|
||||
> {
|
||||
Box::pin(async move {
|
||||
*self
|
||||
.writes
|
||||
.lock()
|
||||
.unwrap()
|
||||
.entry(profile.artifact_key().to_owned())
|
||||
.or_default() += 1;
|
||||
if self.failing_target.lock().unwrap().as_deref() == Some(profile.artifact_key()) {
|
||||
return Err(gateway_core::provider_ports::ProviderStoreError::new(
|
||||
gateway_core::provider_ports::ProviderStoreErrorKind::Unavailable,
|
||||
"write CLI fixture",
|
||||
));
|
||||
}
|
||||
Ok(true)
|
||||
})
|
||||
}
|
||||
|
||||
fn read<'a>(
|
||||
&'a self,
|
||||
_provider: &'a gateway_core::routing::ProviderKind,
|
||||
_key: &'a str,
|
||||
) -> futures::future::BoxFuture<
|
||||
'a,
|
||||
Result<
|
||||
Option<gateway_core::provider_ports::ProviderArtifactProfile>,
|
||||
gateway_core::provider_ports::ProviderStoreError,
|
||||
>,
|
||||
> {
|
||||
Box::pin(async { Ok(None) })
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(start_paused = true)]
|
||||
async fn unchanged_cli_release_only_renews_cache_daily_and_preserves_verification_time() {
|
||||
use provider_openai::transport::profile::{
|
||||
CodexWireProfileState,
|
||||
cli_release::CliReleaseService,
|
||||
selection::{ClientKind, ClientPlatform},
|
||||
};
|
||||
use std::{sync::Arc, time::Duration};
|
||||
let state = CodexWireProfileState::new(super::wire_profile());
|
||||
let cache = Arc::new(CliCache::default());
|
||||
let transport = Arc::new(CliTransport {
|
||||
version: std::sync::Mutex::new("1.0.0".to_owned()),
|
||||
});
|
||||
let service = CliReleaseService::with_transport(
|
||||
gateway_core::routing::ProviderKind::new("openai").unwrap(),
|
||||
state.clone(),
|
||||
cache.clone(),
|
||||
transport,
|
||||
);
|
||||
service.refresh().await.unwrap();
|
||||
let verified = state
|
||||
.client_release(ClientKind::Cli, ClientPlatform::Linux, "x86_64")
|
||||
.unwrap();
|
||||
tokio::time::advance(Duration::from_secs(3600)).await;
|
||||
service.refresh().await.unwrap();
|
||||
assert!(
|
||||
cache
|
||||
.writes
|
||||
.lock()
|
||||
.unwrap()
|
||||
.values()
|
||||
.all(|count| *count == 1)
|
||||
);
|
||||
tokio::time::advance(Duration::from_secs(23 * 3600)).await;
|
||||
service.refresh().await.unwrap();
|
||||
assert!(
|
||||
cache
|
||||
.writes
|
||||
.lock()
|
||||
.unwrap()
|
||||
.values()
|
||||
.all(|count| *count == 2)
|
||||
);
|
||||
assert_eq!(
|
||||
state
|
||||
.client_release(ClientKind::Cli, ClientPlatform::Linux, "x86_64")
|
||||
.unwrap(),
|
||||
verified
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test(start_paused = true)]
|
||||
async fn cli_partial_cache_failure_retries_the_same_release_without_republishing_other_targets() {
|
||||
use provider_openai::transport::profile::{
|
||||
CodexWireProfileState,
|
||||
cli_release::CliReleaseService,
|
||||
selection::{ClientKind, ClientPlatform},
|
||||
};
|
||||
use std::{sync::Arc, time::Duration};
|
||||
let state = CodexWireProfileState::new(super::wire_profile());
|
||||
let original = state
|
||||
.client_release(ClientKind::Cli, ClientPlatform::Linux, "x86_64")
|
||||
.unwrap();
|
||||
let cache = Arc::new(CliCache::default());
|
||||
*cache.failing_target.lock().unwrap() = Some("cli-linux-x64".to_owned());
|
||||
let transport = Arc::new(CliTransport {
|
||||
version: std::sync::Mutex::new("1.0.0".to_owned()),
|
||||
});
|
||||
let service = CliReleaseService::with_transport(
|
||||
gateway_core::routing::ProviderKind::new("openai").unwrap(),
|
||||
state.clone(),
|
||||
cache.clone(),
|
||||
transport,
|
||||
);
|
||||
service.refresh().await.unwrap();
|
||||
assert_eq!(
|
||||
state
|
||||
.client_release(ClientKind::Cli, ClientPlatform::Linux, "x86_64")
|
||||
.unwrap(),
|
||||
original
|
||||
);
|
||||
assert!(
|
||||
state
|
||||
.client_release_status(ClientKind::Cli, ClientPlatform::Linux, "x86_64")
|
||||
.1
|
||||
.is_some()
|
||||
);
|
||||
*cache.failing_target.lock().unwrap() = None;
|
||||
tokio::time::advance(Duration::from_secs(3600)).await;
|
||||
service.refresh().await.unwrap();
|
||||
assert_eq!(
|
||||
state
|
||||
.client_release(ClientKind::Cli, ClientPlatform::Linux, "x86_64")
|
||||
.unwrap()
|
||||
.codex_version,
|
||||
"1.0.0"
|
||||
);
|
||||
assert!(
|
||||
state
|
||||
.client_release_status(ClientKind::Cli, ClientPlatform::Linux, "x86_64")
|
||||
.1
|
||||
.is_none()
|
||||
);
|
||||
let writes = cache.writes.lock().unwrap();
|
||||
assert_eq!(writes["cli-linux-x64"], 2);
|
||||
assert!(
|
||||
writes
|
||||
.iter()
|
||||
.filter(|(key, _)| key.as_str() != "cli-linux-x64")
|
||||
.all(|(_, count)| *count == 1)
|
||||
);
|
||||
}
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
//! 客户端画像测试入口,以及 Desktop 发行解析和原子更新测试
|
||||
|
||||
use std::collections::VecDeque;
|
||||
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
|
||||
use std::sync::{Arc, Mutex};
|
||||
use std::time::Duration;
|
||||
|
||||
@@ -75,14 +76,16 @@ impl CodexDesktopReleaseTransport for ReleaseTransport {
|
||||
#[derive(Default)]
|
||||
struct ArtifactProfiles {
|
||||
profile: Mutex<Option<ProviderArtifactProfile>>,
|
||||
fail_writes: bool,
|
||||
fail_writes: AtomicBool,
|
||||
writes: AtomicUsize,
|
||||
}
|
||||
|
||||
impl ArtifactProfiles {
|
||||
fn failing() -> Self {
|
||||
Self {
|
||||
profile: Mutex::new(None),
|
||||
fail_writes: true,
|
||||
fail_writes: AtomicBool::new(true),
|
||||
writes: AtomicUsize::new(0),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -94,7 +97,8 @@ impl ProviderArtifactProfileCachePort for ArtifactProfiles {
|
||||
_ttl: Duration,
|
||||
) -> BoxFuture<'_, Result<bool, ProviderStoreError>> {
|
||||
Box::pin(async move {
|
||||
if self.fail_writes {
|
||||
self.writes.fetch_add(1, Ordering::SeqCst);
|
||||
if self.fail_writes.load(Ordering::SeqCst) {
|
||||
return Err(ProviderStoreError::new(
|
||||
ProviderStoreErrorKind::Unavailable,
|
||||
"replace test artifact profile",
|
||||
@@ -272,19 +276,34 @@ async fn bundled_release_update_should_change_core_and_desktop_identity_atomical
|
||||
assert_eq!(transport.core_probes(), 1);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn unchanged_verified_release_should_refresh_cache_without_downloading_core_again() {
|
||||
#[tokio::test(start_paused = true)]
|
||||
async fn unchanged_verified_release_renews_cache_daily_without_downloading_core_again() {
|
||||
let state = CodexWireProfileState::new(wire_profile());
|
||||
let latest = release("26.810.41047", "6570");
|
||||
let transport = Arc::new(ReleaseTransport::new(
|
||||
[Ok(latest.clone()), Ok(latest)],
|
||||
(0..5).map(|_| Ok(latest.clone())),
|
||||
[Ok("0.148.0-alpha.9".to_owned())],
|
||||
));
|
||||
let cache = Arc::new(ArtifactProfiles::default());
|
||||
let service = service(state, transport.clone(), cache, None);
|
||||
let service = service(state.clone(), transport.clone(), cache.clone(), None);
|
||||
|
||||
service.refresh().await.expect("first release refresh");
|
||||
let verified = state.snapshot();
|
||||
tokio::time::advance(Duration::from_secs(60 * 60)).await;
|
||||
service.refresh().await.expect("cached release refresh");
|
||||
assert_eq!(cache.writes.load(Ordering::SeqCst), 1);
|
||||
|
||||
tokio::time::advance(Duration::from_secs(23 * 60 * 60)).await;
|
||||
cache.fail_writes.store(true, Ordering::SeqCst);
|
||||
service.refresh().await.expect_err("renewal failure");
|
||||
assert_eq!(state.snapshot(), verified);
|
||||
cache.fail_writes.store(false, Ordering::SeqCst);
|
||||
service.refresh().await.expect("retry renewal");
|
||||
assert_eq!(cache.writes.load(Ordering::SeqCst), 3);
|
||||
service.refresh().await.expect("renewed cache");
|
||||
assert_eq!(cache.writes.load(Ordering::SeqCst), 3);
|
||||
assert_eq!(state.snapshot(), verified);
|
||||
assert!(service.status().snapshot().last_error.is_none());
|
||||
|
||||
assert_eq!(transport.core_probes(), 1);
|
||||
}
|
||||
@@ -329,15 +348,11 @@ async fn cache_failure_should_not_publish_a_partially_verified_profile() {
|
||||
let original = wire_profile();
|
||||
let state = CodexWireProfileState::new(original.clone());
|
||||
let transport = Arc::new(ReleaseTransport::new(
|
||||
[Ok(release("26.810.41047", "6570"))],
|
||||
[Ok("0.148.0-alpha.9".to_owned())],
|
||||
(0..2).map(|_| Ok(release("26.810.41047", "6570"))),
|
||||
(0..2).map(|_| Ok("0.148.0-alpha.9".to_owned())),
|
||||
));
|
||||
let service = service(
|
||||
state.clone(),
|
||||
transport,
|
||||
Arc::new(ArtifactProfiles::failing()),
|
||||
None,
|
||||
);
|
||||
let cache = Arc::new(ArtifactProfiles::failing());
|
||||
let service = service(state.clone(), transport, cache.clone(), None);
|
||||
|
||||
service
|
||||
.refresh()
|
||||
@@ -346,6 +361,9 @@ async fn cache_failure_should_not_publish_a_partially_verified_profile() {
|
||||
|
||||
assert_eq!(state.snapshot(), original);
|
||||
assert!(service.status().snapshot().latest.is_none());
|
||||
cache.fail_writes.store(false, Ordering::SeqCst);
|
||||
service.refresh().await.expect("retry same release");
|
||||
assert_eq!(state.snapshot().desktop_build, "6570");
|
||||
}
|
||||
|
||||
/// 滞后档位按发布观察序列解析:启动种子、历次核验发布与失败观察共同构成历史。
|
||||
|
||||
@@ -150,6 +150,39 @@ fn windows_reads_versions_within_budget_despite_large_unrelated_entries() {
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn windows_reads_zip64_end_records_with_sentinel_directory_fields() {
|
||||
let mut bytes = zip(false, &core(true, false));
|
||||
let expected = read_windows(Cursor::new(&bytes), "x86_64").unwrap();
|
||||
let end = bytes.len() - 22;
|
||||
let mut eocd = bytes.split_off(end);
|
||||
assert_eq!(&eocd[..4], b"PK\x05\x06");
|
||||
let entries = u64::from(u16::from_le_bytes(eocd[10..12].try_into().unwrap()));
|
||||
let directory_size = u64::from(u32::from_le_bytes(eocd[12..16].try_into().unwrap()));
|
||||
let directory_offset = u64::from(u32::from_le_bytes(eocd[16..20].try_into().unwrap()));
|
||||
// MSIX 即使不足 4 GiB 也使用 ZIP64 尾记录,并把普通 EOCD 目录字段置为哨兵
|
||||
bytes.extend_from_slice(b"PK\x06\x06");
|
||||
bytes.extend_from_slice(&44_u64.to_le_bytes());
|
||||
bytes.extend_from_slice(&45_u16.to_le_bytes());
|
||||
bytes.extend_from_slice(&45_u16.to_le_bytes());
|
||||
bytes.extend_from_slice(&[0; 8]);
|
||||
for value in [entries, entries, directory_size, directory_offset] {
|
||||
bytes.extend_from_slice(&value.to_le_bytes());
|
||||
}
|
||||
bytes.extend_from_slice(b"PK\x06\x07");
|
||||
bytes.extend_from_slice(&0_u32.to_le_bytes());
|
||||
bytes.extend_from_slice(&(end as u64).to_le_bytes());
|
||||
bytes.extend_from_slice(&1_u32.to_le_bytes());
|
||||
eocd[8..20].fill(0xff);
|
||||
bytes.extend(eocd);
|
||||
assert_eq!(
|
||||
read_windows(ReadBudget(Cursor::new(&bytes).take(64 * 1024)), "x86_64").unwrap(),
|
||||
expected
|
||||
);
|
||||
bytes[end..end + 4].fill(0);
|
||||
assert!(read_windows(Cursor::new(bytes), "x86_64").is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn truncated_or_corrupt_archives_do_not_publish_versions() {
|
||||
let zip = zip(false, &core(true, false));
|
||||
|
||||
@@ -14,6 +14,7 @@ use provider_openai::transport::profile::selection::{ClientKind, ClientProfileSe
|
||||
use serde_json::json;
|
||||
use std::collections::BTreeMap;
|
||||
use std::io;
|
||||
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
|
||||
use std::sync::{Arc, Mutex};
|
||||
use std::time::Duration;
|
||||
|
||||
@@ -24,7 +25,8 @@ mod xz;
|
||||
#[derive(Default)]
|
||||
struct Cache {
|
||||
profiles: Mutex<BTreeMap<String, ProviderArtifactProfile>>,
|
||||
reject: bool,
|
||||
reject: AtomicBool,
|
||||
writes: AtomicUsize,
|
||||
}
|
||||
impl ProviderArtifactProfileCachePort for Cache {
|
||||
fn read<'a>(
|
||||
@@ -40,7 +42,8 @@ impl ProviderArtifactProfileCachePort for Cache {
|
||||
_ttl: Duration,
|
||||
) -> BoxFuture<'_, Result<bool, ProviderStoreError>> {
|
||||
Box::pin(async move {
|
||||
if self.reject {
|
||||
self.writes.fetch_add(1, Ordering::Relaxed);
|
||||
if self.reject.load(Ordering::Relaxed) {
|
||||
return Ok(false);
|
||||
}
|
||||
self.profiles
|
||||
@@ -63,14 +66,26 @@ impl DesktopArtifactTransport for Transport {
|
||||
previous: Option<VerifiedArtifact>,
|
||||
) -> BoxFuture<'_, io::Result<VerifiedArtifact>> {
|
||||
Box::pin(async move {
|
||||
if previous.is_some() {
|
||||
*self.seen_previous.lock().unwrap() += 1;
|
||||
}
|
||||
let previous = previous.expect("target has an offline artifact");
|
||||
*self.seen_previous.lock().unwrap() += 1;
|
||||
let round = *self.round.lock().unwrap();
|
||||
if round == 1 && target == TARGETS[0] {
|
||||
return Err(io::Error::other("fixture outage"));
|
||||
}
|
||||
let build = if round == 2 { 1 } else { 20000 + round };
|
||||
if round == 3 {
|
||||
return Ok(previous);
|
||||
}
|
||||
let build = if round == 2 {
|
||||
1
|
||||
} else {
|
||||
previous
|
||||
.release
|
||||
.desktop_build
|
||||
.unwrap()
|
||||
.parse::<u64>()
|
||||
.unwrap()
|
||||
+ 1
|
||||
};
|
||||
Ok(serde_json::from_value(json!({"identity":{"etag":format!("\"{build}\""),"size":1000}, "release":{"codexVersion":format!("0.200.{round}"), "desktopVersion":format!("30.1.{round}"), "desktopBuild":build.to_string(), "verifiedAt":null}})).unwrap())
|
||||
})
|
||||
}
|
||||
@@ -127,22 +142,85 @@ async fn releases_are_independent_atomic_cached_and_preserved_on_failures_or_rol
|
||||
.await;
|
||||
assert_eq!(selection.resolve(&restored).unwrap(), frozen);
|
||||
}
|
||||
#[tokio::test(start_paused = true)]
|
||||
async fn unchanged_artifacts_renew_daily_and_keep_verification_time() {
|
||||
let state = CodexWireProfileState::new(super::wire_profile());
|
||||
let cache = Arc::new(Cache::default());
|
||||
let transport = Arc::new(Transport::default());
|
||||
*transport.round.lock().unwrap() = 3;
|
||||
let service = service(state.clone(), cache.clone(), transport);
|
||||
let target = TARGETS[0];
|
||||
let original = state.client_release(ClientKind::Desktop, target.platform, target.arch);
|
||||
service.refresh().await;
|
||||
assert_eq!(cache.writes.load(Ordering::Relaxed), 4);
|
||||
tokio::time::advance(Duration::from_secs(60 * 60)).await;
|
||||
service.refresh().await;
|
||||
assert_eq!(cache.writes.load(Ordering::Relaxed), 4);
|
||||
for day in 1..=31 {
|
||||
tokio::time::advance(Duration::from_secs(24 * 60 * 60)).await;
|
||||
service.refresh().await;
|
||||
assert_eq!(cache.writes.load(Ordering::Relaxed), 4 * (day + 1));
|
||||
assert_eq!(
|
||||
state.client_release(ClientKind::Desktop, target.platform, target.arch),
|
||||
original
|
||||
);
|
||||
}
|
||||
cache.reject.store(true, Ordering::Relaxed);
|
||||
tokio::time::advance(Duration::from_secs(24 * 60 * 60)).await;
|
||||
service.refresh().await;
|
||||
assert!(
|
||||
state
|
||||
.client_release_status(ClientKind::Desktop, target.platform, target.arch)
|
||||
.1
|
||||
.is_some()
|
||||
);
|
||||
cache.reject.store(false, Ordering::Relaxed);
|
||||
tokio::time::advance(Duration::from_secs(60 * 60)).await;
|
||||
service.refresh().await;
|
||||
assert_eq!(cache.writes.load(Ordering::Relaxed), 4 * 34);
|
||||
assert!(
|
||||
state
|
||||
.client_release_status(ClientKind::Desktop, target.platform, target.arch)
|
||||
.1
|
||||
.is_none()
|
||||
);
|
||||
assert_eq!(
|
||||
state.client_release(ClientKind::Desktop, target.platform, target.arch),
|
||||
original
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn cache_rejection_keeps_the_previous_release() {
|
||||
async fn cache_rejection_preserves_previous_release_and_retries_same_artifact() {
|
||||
let state = CodexWireProfileState::new(super::wire_profile());
|
||||
let before = state.client_release(ClientKind::Desktop, TARGETS[0].platform, TARGETS[0].arch);
|
||||
service(
|
||||
state.clone(),
|
||||
Arc::new(Cache {
|
||||
reject: true,
|
||||
..Default::default()
|
||||
}),
|
||||
Arc::new(Transport::default()),
|
||||
)
|
||||
.refresh()
|
||||
.await;
|
||||
let cache = Arc::new(Cache {
|
||||
reject: AtomicBool::new(true),
|
||||
..Default::default()
|
||||
});
|
||||
let transport = Arc::new(Transport::default());
|
||||
let service = service(state.clone(), cache.clone(), transport);
|
||||
service.refresh().await;
|
||||
assert_eq!(
|
||||
state.client_release(ClientKind::Desktop, TARGETS[0].platform, TARGETS[0].arch),
|
||||
before
|
||||
);
|
||||
cache.reject.store(false, Ordering::Relaxed);
|
||||
service.refresh().await;
|
||||
assert_eq!(cache.writes.load(Ordering::Relaxed), 8);
|
||||
for target in TARGETS {
|
||||
assert_eq!(
|
||||
state
|
||||
.client_release(ClientKind::Desktop, target.platform, target.arch)
|
||||
.unwrap()
|
||||
.codex_version,
|
||||
"0.200.0"
|
||||
);
|
||||
assert!(
|
||||
state
|
||||
.client_release_status(ClientKind::Desktop, target.platform, target.arch)
|
||||
.1
|
||||
.is_none()
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4,12 +4,19 @@ use gateway_core::account::OpaqueProviderData;
|
||||
use provider_openai::transport::profile::selection::{
|
||||
CliEntry, ClientKind, ClientPlatform, ClientProfileSelection, VersionMode,
|
||||
};
|
||||
use provider_openai::transport::profile::{CodexBundledReleaseProfile, CodexWireProfileState};
|
||||
use provider_openai::transport::profile::{
|
||||
CodexBundledReleaseProfile, CodexWireProfile, CodexWireProfileState,
|
||||
};
|
||||
use serde_json::json;
|
||||
|
||||
#[test]
|
||||
fn six_presets_have_explicit_availability_and_cli_has_no_desktop_suffix() {
|
||||
let state = CodexWireProfileState::new(super::wire_profile());
|
||||
let state = CodexWireProfileState::new(CodexWireProfile::default());
|
||||
assert_eq!(
|
||||
ClientProfileSelection::default().resolve(&state).unwrap(),
|
||||
state.snapshot(),
|
||||
"default requests and the default preset must use the same identity"
|
||||
);
|
||||
let options = state.selection_options().unwrap();
|
||||
let presets = options.expose_to_provider()["presets"].as_array().unwrap();
|
||||
assert_eq!(presets.len(), 6);
|
||||
@@ -34,6 +41,7 @@ fn six_presets_have_explicit_availability_and_cli_has_no_desktop_suffix() {
|
||||
assert!(profile.desktop_version.is_empty());
|
||||
assert!(!profile.user_agent().contains("Desktop"));
|
||||
assert!(profile.user_agent().ends_with("unknown"));
|
||||
assert!(profile.verified_at > chrono::DateTime::UNIX_EPOCH);
|
||||
}
|
||||
for platform in [ClientPlatform::Linux, ClientPlatform::Windows] {
|
||||
for arch in ["arm64", "x86_64"] {
|
||||
@@ -46,6 +54,7 @@ fn six_presets_have_explicit_availability_and_cli_has_no_desktop_suffix() {
|
||||
assert_eq!(profile.os_type, platform.os_type());
|
||||
assert_eq!(profile.arch, arch);
|
||||
assert!(profile.desktop_version.starts_with("26."));
|
||||
assert!(profile.verified_at > chrono::DateTime::UNIX_EPOCH);
|
||||
}
|
||||
}
|
||||
let unsupported = ClientProfileSelection {
|
||||
|
||||
@@ -1,8 +1,213 @@
|
||||
//! 验证上游停止读请求时,发送超时仍能返回并释放连接
|
||||
//! 验证上下游背压、取消与终态下的连接和任务回收
|
||||
|
||||
use super::*;
|
||||
use gateway_core::{
|
||||
diagnostics::TraceContext, engine::response_control::ResponseControl,
|
||||
lifecycle::CancellationToken,
|
||||
};
|
||||
use std::assert_matches;
|
||||
|
||||
async fn wait_for_forwarded_frames(trace: &TraceContext, stage: &str, count: u64) {
|
||||
timeout(Duration::from_secs(2), async {
|
||||
while trace.snapshot().unwrap()["stageCounts"][stage]
|
||||
.as_u64()
|
||||
.unwrap_or_default()
|
||||
< count
|
||||
{
|
||||
tokio::task::yield_now().await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.expect("forwarder should reach the backpressured frame");
|
||||
}
|
||||
|
||||
fn response_tail(kind: &str) -> Message {
|
||||
match kind {
|
||||
"binary" => Message::Binary(vec![0].into()),
|
||||
"delta" => Message::Text(
|
||||
json!({"type":"response.output_text.delta", "delta":"x"})
|
||||
.to_string()
|
||||
.into(),
|
||||
),
|
||||
"completed" => {
|
||||
Message::Text(completed_websocket_response("resp_backpressure", 2, 1).into())
|
||||
}
|
||||
kind => Message::Text(
|
||||
json!({"type":format!("response.{kind}"), "response":{
|
||||
"id":"resp_backpressure", "status":kind, "output":[]
|
||||
}})
|
||||
.to_string()
|
||||
.into(),
|
||||
),
|
||||
}
|
||||
}
|
||||
|
||||
async fn send_backpressured_response(
|
||||
websocket: &mut tokio_tungstenite::WebSocketStream<TcpStream>,
|
||||
tail: &str,
|
||||
) {
|
||||
// 先填满交付队列,后续帧由诊断计数确认已到达 forwarder,不靠 sleep 猜测调度
|
||||
for _ in 0..16 {
|
||||
websocket.send(response_tail("delta")).await.unwrap();
|
||||
}
|
||||
websocket.send(response_tail(tail)).await.unwrap();
|
||||
}
|
||||
|
||||
async fn expect_upstream_socket_closed(
|
||||
websocket: &mut tokio_tungstenite::WebSocketStream<TcpStream>,
|
||||
) {
|
||||
let close = timeout(Duration::from_secs(2), websocket.next())
|
||||
.await
|
||||
.expect("cancellation must release the socket while the receiver remains alive");
|
||||
assert_matches!(
|
||||
close,
|
||||
None | Some(Ok(Message::Close(_)))
|
||||
| Some(Err(tungstenite::Error::Protocol(
|
||||
tungstenite::error::ProtocolError::ResetWithoutClosingHandshake
|
||||
)))
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn backpressured_delivery_should_stop_on_downstream_cancel_or_pool_shutdown() {
|
||||
for cancel_downstream in [true, false] {
|
||||
for tail in ["delta", "binary", "completed", "failed", "incomplete"] {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let addr = listener.local_addr().unwrap();
|
||||
let mut server = tokio::spawn(async move {
|
||||
let (socket, _) = listener.accept().await.unwrap();
|
||||
let mut websocket = accept_codex_test_websocket(socket).await;
|
||||
websocket.next().await.unwrap().unwrap();
|
||||
send_backpressured_response(&mut websocket, tail).await;
|
||||
expect_upstream_socket_closed(&mut websocket).await;
|
||||
});
|
||||
let pool = Arc::new(CodexWebSocketPool::default());
|
||||
let backend = CodexBackendClient::new(
|
||||
reqwest::Client::builder().no_proxy().build().unwrap(),
|
||||
format!("http://{addr}"),
|
||||
test_wire_profile(),
|
||||
)
|
||||
.with_websocket_pool(Arc::clone(&pool));
|
||||
let cancellation = CancellationToken::new();
|
||||
let control =
|
||||
ResponseControl::default().with_connection_cancellation(cancellation.clone());
|
||||
let trace = TraceContext::new("backpressured_delivery");
|
||||
let mut context = request_context("backpressured_delivery", Some("chatgpt-account"))
|
||||
.with_response_control(Some(&control));
|
||||
context.trace = Some(&trace);
|
||||
let mut request = pooled_websocket_request("backpressured_delivery");
|
||||
request.downstream_websocket_connection_id = Some("downstream_backpressure".into());
|
||||
let mut response = backend
|
||||
.create_response_stream(&request, context)
|
||||
.await
|
||||
.unwrap();
|
||||
let (stage, count) = if tail == "binary" {
|
||||
("upstream.binary", 1)
|
||||
} else {
|
||||
("upstream.event", 17)
|
||||
};
|
||||
wait_for_forwarded_frames(&trace, stage, count).await;
|
||||
|
||||
if cancel_downstream {
|
||||
cancellation.cancel();
|
||||
// 必须在 shutdown 前看到物理连接关闭,避免停机掩盖下游取消失效
|
||||
(&mut server).await.unwrap();
|
||||
}
|
||||
timeout(Duration::from_secs(2), pool.shutdown())
|
||||
.await
|
||||
.expect("shutdown must join delivery even with a full receiver");
|
||||
if !cancel_downstream {
|
||||
(&mut server).await.unwrap();
|
||||
}
|
||||
// 收尾前不消费也不丢弃 body,已交付的事件仍可正常读完
|
||||
let mut buffered = 0;
|
||||
while response.body.next().await.transpose().unwrap().is_some() {
|
||||
buffered += 1;
|
||||
}
|
||||
assert_eq!(
|
||||
buffered, 16,
|
||||
"tail={tail}, cancel_downstream={cancel_downstream}"
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn terminal_should_release_or_reuse_socket_before_delivery() {
|
||||
for tail in ["completed", "failed", "incomplete"] {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let addr = listener.local_addr().unwrap();
|
||||
let mut server = tokio::spawn(async move {
|
||||
let (socket, _) = listener.accept().await.unwrap();
|
||||
let mut websocket = accept_codex_test_websocket(socket).await;
|
||||
websocket.next().await.unwrap().unwrap();
|
||||
send_backpressured_response(&mut websocket, tail).await;
|
||||
if tail == "completed" {
|
||||
let next = timeout(Duration::from_secs(2), websocket.next())
|
||||
.await
|
||||
.expect("continuation should reuse the completed socket")
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let Message::Text(next) = next else {
|
||||
panic!("expected continuation request");
|
||||
};
|
||||
assert_eq!(
|
||||
serde_json::from_str::<Value>(&next).unwrap()["previous_response_id"],
|
||||
"resp_backpressure"
|
||||
);
|
||||
websocket
|
||||
.send(Message::Text(
|
||||
completed_websocket_response("resp_next", 2, 1).into(),
|
||||
))
|
||||
.await
|
||||
.unwrap();
|
||||
}
|
||||
expect_upstream_socket_closed(&mut websocket).await;
|
||||
});
|
||||
let pool = Arc::new(CodexWebSocketPool::default());
|
||||
let backend = CodexBackendClient::new(
|
||||
reqwest::Client::builder().no_proxy().build().unwrap(),
|
||||
format!("http://{addr}"),
|
||||
test_wire_profile(),
|
||||
)
|
||||
.with_websocket_pool(Arc::clone(&pool));
|
||||
let trace = TraceContext::new("terminal_delivery");
|
||||
let mut context = request_context("terminal_delivery", Some("chatgpt-account"));
|
||||
context.trace = Some(&trace);
|
||||
let mut request = pooled_websocket_request("terminal_delivery");
|
||||
let mut response = backend
|
||||
.create_response_stream(&request, context)
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for_forwarded_frames(&trace, "upstream.event", 17).await;
|
||||
if tail == "completed" {
|
||||
request.set_previous_response_id(Some("resp_backpressure".into()));
|
||||
request.previous_response_scope = Some(PreviousResponseScope::ConnectionLocal);
|
||||
let next = backend
|
||||
.create_response(
|
||||
&request,
|
||||
request_context("terminal_next", Some("chatgpt-account")),
|
||||
)
|
||||
.await
|
||||
.expect("completed continuation should be reusable before terminal consumption");
|
||||
assert!(next.websocket_pool_decision.unwrap().is_reuse());
|
||||
} else {
|
||||
// 失败终态必须释放 socket,不能依赖客户端读走终态
|
||||
(&mut server).await.unwrap();
|
||||
}
|
||||
let mut events = Vec::new();
|
||||
while let Some(chunk) = response.body.next().await {
|
||||
events.push(serde_json::from_slice::<Value>(&chunk.unwrap()).unwrap());
|
||||
}
|
||||
assert_eq!(events.len(), 17);
|
||||
assert_eq!(events.last().unwrap()["type"], format!("response.{tail}"));
|
||||
pool.shutdown().await;
|
||||
if tail == "completed" {
|
||||
(&mut server).await.unwrap();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn send_timeout_should_abort_stalled_pump_and_allow_next_request() {
|
||||
let socket = tokio::net::TcpSocket::new_v4().unwrap();
|
||||
|
||||
@@ -100,6 +100,7 @@ async fn official_websocket_wire_fingerprint_should_remain_aligned() {
|
||||
session_id: Some("session-fingerprint"),
|
||||
thread_id: Some("thread-fingerprint"),
|
||||
client_request_id: Some("request-fingerprint"),
|
||||
installation_id: Some("3b11bc82-c666-417d-b9ff-2a34fd040385"),
|
||||
..request_context("req_wire_fingerprint", Some("account-fingerprint"))
|
||||
},
|
||||
)
|
||||
@@ -151,7 +152,6 @@ async fn official_websocket_wire_fingerprint_should_remain_aligned() {
|
||||
read_header_value(&opening, "originator"),
|
||||
read_header_value(&opening, "version"),
|
||||
read_header_value(&opening, "openai-beta"),
|
||||
read_header_value(&opening, "x-client-request-id"),
|
||||
read_header_value(&opening, "x-codex-routing-hint"),
|
||||
),
|
||||
(
|
||||
@@ -160,10 +160,12 @@ async fn official_websocket_wire_fingerprint_should_remain_aligned() {
|
||||
Some("codex_cli_rs"),
|
||||
Some("1.2.3"),
|
||||
Some("responses_websockets=2026-02-06"),
|
||||
Some("request-fingerprint"),
|
||||
Some("model=gpt-5.5"),
|
||||
)
|
||||
);
|
||||
let request_id = read_header_value(&opening, "x-client-request-id").unwrap();
|
||||
assert_ne!(request_id, "request-fingerprint");
|
||||
assert!(uuid::Uuid::parse_str(request_id).is_ok());
|
||||
assert_eq!(
|
||||
STANDARD
|
||||
.decode(websocket_key)
|
||||
|
||||
@@ -39,3 +39,5 @@ b215ea90d5c8753aeb8192b17ffe65f7a95c1d620aaeaf9fc4337d8cf6f2634e 0037_retry_aft
|
||||
a6b4e81d38e5d70776a75eba22749354573ebcb186160ff9eb45fd91157b3e0d 0039_queue_timeouts_quota_credits_and_installation_seed.sql
|
||||
cd9e31400fc6b0d49a6515048c104341fca2cf44f290d89c401b41f94ead84a3 0040_account_scheduling_key_budgets_and_peer_routing.sql
|
||||
aeff99fee7cef5a553ae49ffe27a48f49e31ccfb3fbc61a2482c9b109478202d 0041_account_model_catalogs.sql
|
||||
19eba6b493647da51996831f72d7bc83e95416c06f207ea685f8f5e2edea7c64 0042_usage_retention_days.sql
|
||||
223589308df852154004385b13c91a03714114fb9472f00472099bcf2c131cb3 0043_quota_reset_window_weights.sql
|
||||
|
||||
@@ -0,0 +1,7 @@
|
||||
-- 保留期仅要求正整数天数,沿用当前设置与默认值
|
||||
alter table runtime_settings drop constraint runtime_settings_retention_ck;
|
||||
alter table runtime_settings add constraint runtime_settings_retention_ck check (
|
||||
usage_retention_days > 0
|
||||
and ops_event_retention_days > 0
|
||||
and audit_retention_days > 0
|
||||
);
|
||||
@@ -0,0 +1,4 @@
|
||||
-- 两种调度策略分别保存窗口偏好,全零沿用最早重置优先
|
||||
alter table runtime_settings
|
||||
add column quota_reset_window_weights_json jsonb not null
|
||||
default '{"fiveHour":0,"weekly":0,"monthly":0}'::jsonb;
|
||||
@@ -122,6 +122,9 @@ store:
|
||||
应用默认上限为 20,允许的最小值为 2;降低上限可以限制实际数据库连接数,但也会增加请求、后台写入与管理查询之间的等待。
|
||||
如果出现连接获取超时,应结合数据库负载调大池容量,不要仅延长等待时间
|
||||
|
||||
统计 Worker 重算分组时,若临时文件写入较多且数据库有内存余量,可在 `store.pool` 下设置 `analytics_projection_work_mem_mb: 8`(单位 MB)。
|
||||
默认省略,沿用 PostgreSQL 的 `work_mem`;显式设置仅影响增量投影和历史回填所在的事务,队列确认、整桶重建和在线查询继续沿用原值
|
||||
|
||||
将 `deploy/compose.yaml` 中 `services.postgres.command` 替换为以下列表,保留 UTC 参数:
|
||||
|
||||
```yaml
|
||||
@@ -382,6 +385,14 @@ HTTP 在数据库迁移和初始化完成后才监听。迁移期间启动日志
|
||||
不要把未脱敏的 `docker compose config` 或 `docker inspect` 输出上传到工单;它们会包含
|
||||
PostgreSQL/Redis 启动密码。日常校验使用 `config --quiet`
|
||||
|
||||
### 安装管理端应用
|
||||
|
||||
使用 Chrome、Edge 等支持 PWA 的浏览器访问管理端,可通过地址栏或浏览器菜单安装应用,安装后以独立窗口打开站点首页,沿用现有登录流程
|
||||
|
||||
在支持自定义标题栏的桌面浏览器中,可用窗口右上角的按钮显示或隐藏系统标题栏。隐藏后仍可拖动顶部空白区域移动窗口
|
||||
|
||||
安装入口要求 HTTPS,或本机的 `http://localhost`、`http://127.0.0.1`;普通 HTTP 局域网地址不满足条件。入口是否显示还取决于浏览器、访问交互及是否已安装。应用需要联网访问网关,不提供离线使用
|
||||
|
||||
### 启动后的运行设置
|
||||
|
||||
在管理端修改以下设置,保存后对新请求生效,重启不会覆盖已保存的选择:
|
||||
|
||||
@@ -52,12 +52,13 @@ store:
|
||||
url: 'redis://127.0.0.1:6379/'
|
||||
# 与 PostgreSQL 共用密码格式要求,并满足 Redis 服务端密码策略
|
||||
password: &redis_password ''
|
||||
# 可选:PostgreSQL 连接池预算;下列值与当前推荐默认一致。
|
||||
# 可选:PostgreSQL 连接池与统计投影配置
|
||||
# 小内存低并发部署的池上限与数据库调优见 deploy/README.md#小内存优化
|
||||
# pool:
|
||||
# max_connections: 20
|
||||
# acquire_timeout_seconds: 5
|
||||
# observability_timeout_seconds: 120 # 观测操作保护时限,不是性能目标
|
||||
# analytics_projection_work_mem_mb: 8 # 仅统计投影事务;省略时沿用数据库设置
|
||||
|
||||
admin:
|
||||
# 不活动期限与从登录起计算的最长有效期,单位为分钟
|
||||
|
||||
+45
-20
@@ -354,6 +354,11 @@ Responses 上游使用 `$.input`,Messages 上游使用 `$.messages`
|
||||
`stream` 缺省或 `false` 返回 JSON,`true` 返回 SSE。每轮由客户端携带所需的完整上下文。Claude Code 用 `--resume` 恢复本地会话后,仍通过 `messages` 发送上下文;网关不缓存对话正文用于下一轮。
|
||||
Messages 没有服务端历史续接或 WebSocket 入口
|
||||
|
||||
Messages 生成请求通过 OpenAI Provider 选号时,优先使用 `x-claude-code-session-id` 识别 Claude Code 会话,
|
||||
缺少有效头部时读取 `metadata.user_id` JSON 字符串中的 `session_id` 或旧格式 `_session_<id>` 后缀。
|
||||
会话标识最长 256 字节,不接受控制字符;普通用户标识和对话内容不用于绑定账号。
|
||||
同一 Client Key 下的会话沿用[账号亲和与换号](#账号亲和与换号)设置,转向 Responses 上游时也适用
|
||||
|
||||
```bash
|
||||
curl https://gateway.example.com/v1/messages \
|
||||
-H "x-api-key: ${CPR_CLIENT_KEY}" \
|
||||
@@ -500,7 +505,9 @@ Responses API Key 与 OAuth 共用模拟客户端画像(`User-Agent`、`origin
|
||||
包括会话、线程、Lite 和其他业务扩展头。
|
||||
上游认证只来自选中的账号;API Key 不携带 OAuth Cookie、ChatGPT 账号身份或下游的
|
||||
`X-OpenAI-Actor-Authorization` 托管认证声明。
|
||||
`x-codex-installation-id` 在 Key 配置种子时,由种子、Key ID 与选中账号 ID 稳定派生;未配置时使用账号已持久化的安装 ID,与正文 `client_metadata` 中的安装身份一致
|
||||
Responses 的安装身份通过正文 `client_metadata` 及 turn metadata 发送,不默认添加独立的
|
||||
`x-codex-installation-id` 请求头,也不透传下游同名头。Key 配置种子时,安装身份由种子、Key ID 与选中账号 ID
|
||||
稳定派生;未配置时使用账号已持久化的安装 ID。Images、Search 和 Live 保留各自的安装头
|
||||
`x-openai-internal-codex-residency` 和 `x-openai-account-routing-override` 分别由部署配置
|
||||
`openai.residency`、`openai.account_routing_override` 控制,配置值原样发送并覆盖客户端同名头,
|
||||
省略或 `null` 时删除对应请求头。配置说明见 [部署与运维](../deploy/README.md#启动后的运行设置)
|
||||
@@ -519,9 +526,12 @@ Responses 明确换号时清理 `traceparent`、`tracestate`、`sentry-trace`、
|
||||
`x-openai-fedramp`,同时清理正文、`client_metadata`、turn metadata 中的同名字段及
|
||||
`ws_request_header_*` 副本。同账号及归属未知时保留原值,业务输入和工具结果保持原始内容
|
||||
|
||||
会话、线程、窗口及父子线程引用在出站时按本次安装身份稳定映射为 UUID;
|
||||
默认使用账号安装身份;Key 配置种子时,每个 Key × 账号组合拥有独立的安装身份,换账号会改变映射。HTTP 请求头、正文 metadata、WS 副本及
|
||||
已识别的 Desktop 自动 Git 上下文使用一致映射。
|
||||
会话、线程及父子线程引用在出站时按本次安装身份稳定映射。UUIDv7 输入保留原始毫秒时间戳和版本,
|
||||
随机部分按安装身份改写;其他标识映射为 UUIDv4 形状,不补造创建时间。
|
||||
官方格式的窗口 ID 保留 `{映射后的 thread_id}:{原窗口序号}` 结构,`context_window_id` 作为独立标识处理;
|
||||
非官方格式的窗口 ID 按普通标识映射。
|
||||
默认使用账号安装身份;Key 配置种子时,每个 Key × 账号组合拥有独立的安装身份,换账号会改变映射。
|
||||
HTTP 请求头、正文 metadata、WS 副本及已识别的 Desktop 自动 Git 上下文使用一致映射,UUIDv7 的创建时间仍可见。
|
||||
轮次及父子轮次引用保留客户端原值,包括输入项的 `internal_chat_message_metadata_passthrough.turn_id`、
|
||||
请求 metadata 中的 `turn_id`、`parent_turn_id`、`root_turn_id`,以及 `x-client-turn-id`、
|
||||
Images 的 `x-codex-image-turn-id` 和 Desktop 自动 Git 上下文的 `clientUserMessageId`。
|
||||
@@ -1373,11 +1383,9 @@ Key 预算及其访问状态随互联默认公开,不要求开启 `shareQuota`
|
||||
例如 Plus 设置 `allowlist` 并选中 luna 的实际 ID,Pro 设置 `denylist` 并选中同一 ID,即可严格分流;
|
||||
Pro 使用 `all` 时也能参与 luna 调度。套餐名称不自动生成或修改规则
|
||||
|
||||
原生 Responses 默认排除有效目录未列出目标模型的账号。OpenAI OAuth 或 API Key 账号的白名单精确包含映射后的上游 ID 时,
|
||||
允许通过该账号请求目录外模型,由上游确认是否可用。此设置只对配置它的账号生效,已有白名单同样适用。
|
||||
账号禁用、Key 分组、认证类型、黑名单和模型冷却仍参与选号。xAI 账号使用有效套餐目录与账号模型政策的交集。
|
||||
OpenAI 只使用该账号当前凭据和套餐对应、最近 30 分钟内同步的目录,不借用同套餐其他账号的模型。
|
||||
没有有效账号目录时交由上游验证,仍执行 `modelAccess`。xAI 使用已知套餐的有效目录缓存
|
||||
原生 OpenAI Responses 按账号当前凭据和套餐最近一次成功同步的目录选号。目录未列出的模型在刷新期间或刷新失败后仍被排除。
|
||||
账号白名单精确包含映射后的上游 ID 时,允许该账号尝试目录外模型;当前凭据和套餐没有目录时,也可在账号模型政策允许的范围内交由上游验证。
|
||||
账号禁用、Key 分组、认证类型、黑名单和模型冷却仍参与选号。xAI 按账号模型政策与有效的套餐目录筛选
|
||||
|
||||
原生 OpenAI Responses 上游返回 `error.code=model_not_found`,且状态为 400/403/404 或流内错误未提供状态时,
|
||||
该账号与模型组合冷却 30 分钟;其他模型仍可使用该账号。仅消息提及模型不支持不触发冷却;
|
||||
@@ -1500,7 +1508,7 @@ OAuth 等待回调期间不持有保护;提交仍拒绝已删除或连接配
|
||||
|
||||
### 账号连接测试 SSE
|
||||
|
||||
`GET /api/admin/accounts/connection-test` 固定探测请求指定的账号,不参与普通账号轮换。成功流沿用
|
||||
`GET /api/admin/accounts/connection-test` 固定探测请求指定的账号,采用当前全局客户端身份,不参与普通账号轮换。成功流沿用
|
||||
`test_start`、`request`、`content`、`test_complete` 事件;失败事件为:
|
||||
|
||||
```json
|
||||
@@ -2157,7 +2165,7 @@ HTTP 返回 `429`,`error.code` 为 `key_daily_budget_exceeded` 或 `key_weekly
|
||||
| [并发与排队](#并发与排队) | `maxConcurrentPerAccount`、`maxWaitingPerKey`、`maxWaitingPerAccount`、`openaiGuardianReservedConcurrency`、`keyQueueTimeoutSeconds`、`accountQueueTimeoutSeconds`、`switchAccountOnQueueFailure` |
|
||||
| [上游重试等待](#容量拒绝与重试) | `maxRetryAfterSeconds` |
|
||||
| [亲和与换号](#账号亲和与换号) | `openaiAccountAffinity`、`openaiSessionAffinityTtlHours`、`maxAccountRotations` |
|
||||
| [调度策略](#智能调度) | `rotationStrategy`、`smartScheduling` |
|
||||
| [调度策略](#智能调度) | `rotationStrategy`、`smartScheduling`、`quotaResetWindowWeights` |
|
||||
| [请求解压](#请求解压上限) | `responsesMaxDecompressedBodyBytes` |
|
||||
| [客户端门禁](#1-鉴权与公共约定) | `minCodexDesktopVersion`、`minCodexCliVersion` |
|
||||
| [历史保留](#历史保留) | `usageRetentionDays`、`opsEventRetentionDays`、`auditRetentionDays` |
|
||||
@@ -2167,7 +2175,7 @@ HTTP 返回 `429`,`error.code` 为 `key_daily_budget_exceeded` 或 `key_weekly
|
||||
|
||||
### 历史保留
|
||||
|
||||
`usageRetentionDays` 控制请求明细及其用量统计的保留天数,默认 31,支持 1~31 的整数天数。
|
||||
`usageRetentionDays` 控制请求明细及其用量统计的保留天数,默认 31,须为正整数,不设业务上限。
|
||||
`opsEventRetentionDays` 与 `auditRetentionDays` 分别控制独立运维事件和管理审计,默认 30、90,均须为正整数
|
||||
|
||||
清理任务每轮读取已保存设置,按完成时间分批删除过期请求及关联事件,不删除运行中的请求;有界单轮结束后等待一分钟再检查。
|
||||
@@ -2178,8 +2186,8 @@ HTTP 返回 `429`,`error.code` 为 `key_daily_budget_exceeded` 或 `key_weekly
|
||||
|
||||
### 账号预热
|
||||
|
||||
定时账号预热默认关闭。`accountWarmupCron` 使用部署时区的五段 Cron 表达式,
|
||||
顺序为分、时、日、月、星期,总长度不超过 255 字节,默认空字符串,关闭时允许留空。
|
||||
定时账号预热默认关闭。`accountWarmupCron` 是字符串,使用半角分号(`;`)分隔多条五段 Cron 表达式,总长度(含分隔符)不超过 255 字节,各条不可留空。默认空字符串,关闭时允许留空。
|
||||
每条规则按部署时区依次匹配分、时、日、月、星期。任一规则命中即执行,例如 `"58 5 * * *;59 10 * * *"` 只在每天 05:58 和 10:59 触发。
|
||||
支持列表、范围和步长,例如 `0 8,13,19 * * *` 每天执行三次,`0 8 * * MON-FRI` 在工作日 08:00 执行。
|
||||
星期可用 `SUN` 至 `SAT` 或数字 1 至 7(日到六),同时指定日与星期时两者均须满足。
|
||||
同一分钟只领取一次;`accountWarmupModel` 默认 `null`,开启前必须填写有效表达式并显式选择模型。
|
||||
@@ -2188,6 +2196,7 @@ HTTP 返回 `429`,`error.code` 为 `key_daily_budget_exceeded` 或 `key_weekly
|
||||
0% 或缺少活跃证据时允许一次轻量预热,不通过倒计时差值判断活跃,也不额外回查额度。
|
||||
因此已激活但显示 0% 的账号也可能收到预热请求。
|
||||
不存在的本地时刻跳过,重复时刻只执行较早一次;执行进度跨重启保留,时钟回拨不补跑已领取时刻之前的时段。
|
||||
预热每轮采用当前 OpenAI 全局客户端身份,不使用单个 Key 的覆盖。
|
||||
只有收到响应成功终态才记为预热成功;预热不计入客户端业务用量
|
||||
|
||||
### 请求位置
|
||||
@@ -2295,7 +2304,7 @@ Guardian 以 `subagent_kind` 或 `client_metadata.x-openai-subagent` 值 `guardi
|
||||
|
||||
### 账号亲和与换号
|
||||
|
||||
`openaiAccountAffinity` 控制 Codex 账号亲和,默认 `strict`(严格):
|
||||
`openaiAccountAffinity` 控制 OpenAI Provider 的账号亲和,包括带明确 Claude Code 会话身份的 [Messages 请求](#messages-请求),默认 `strict`(严格):
|
||||
|
||||
- `relaxed`(宽松):会话内请求直接按 `rotationStrategy` 选号,不优先主账号
|
||||
- `preferred`(优先)优先使用会话主账号,短时满载、限流或模型不匹配时临时分流,后备按同一会话的稳定顺序参与既有调度
|
||||
@@ -2356,13 +2365,26 @@ Chat Completions 和 Responses 通过原生 OpenAI Provider 选号时,缺少
|
||||
缺少必填系数、系数为 `null`、未知字段及无效数值均返回 `422`,不写入配置。读取设置额外返回只读
|
||||
`smartSchedulingDefaults`,内容为上述默认对象,用于恢复默认与自定义状态比较,不可提交到更新接口
|
||||
|
||||
`resetWeight` 控制重置分在总评分中的比重。`resetWindowWeights` 中的 `fiveHour`、`weekly`、`monthly` 分别表示 5 小时、周和月的相对系数。三项均为 0~10、最多一位小数。默认均为 0,旧配置省略整个字段时也取 0;全部为 0 时不计重置分。设为 `{"fiveHour":0,"weekly":1,"monthly":0}` 可只按周重置评分。只计算账号通用窗口,未知、缺失或已过期的周期贡献为零;独立的 `quota_reset_priority` 策略仍按最早有效重置时间排序
|
||||
`resetWeight` 控制重置分在总评分中的比重。`resetWindowWeights` 中的 `fiveHour`、`weekly`、`monthly` 分别表示 5 小时、周和月的相对系数。三项均为 0~10、最多一位小数。默认均为 0,旧配置省略整个字段时也取 0;全部为 0 时不计重置分。设为 `{"fiveHour":0,"weekly":1,"monthly":0}` 可只按周重置评分。只计算账号通用窗口,未知、缺失或已过期的周期贡献为零
|
||||
|
||||
`queueWeight` 只在没有可立即使用的账号、需要选择等待队列时参与评分,越大越偏向等待人数少的账号。
|
||||
设为 `0` 时沿用最短队列规则;启用后结合其余五项评分选择队列。队列人数限于当前进程,只有开启账号排队才会生效,
|
||||
不影响已入队请求的位置、队内 FIFO、容量上限或等待超时。两项默认均为 `0`
|
||||
|
||||
没有可用亲和时,在最高可用权重层内按配置评分。原生续写账号绑定仍是硬约束。
|
||||
额度调度 `quota_reset_priority` 使用独立的必填完整对象 `quotaResetWindowWeights`,与智能调度分别保存:
|
||||
|
||||
```json
|
||||
{ "fiveHour": 0.0, "weekly": 0.0, "monthly": 0.0 }
|
||||
```
|
||||
|
||||
三项范围均为 `0~10`、最多一位小数,全部为 `0` 时按账号最早有效重置时间排序。
|
||||
任一项大于 `0` 时,只比较所选窗口的加权重置分,严格优先最高分,不混入其他评分维度,也不轮换近似同分账号。
|
||||
设为 `{"fiveHour":0,"weekly":1,"monthly":0}` 即可优先周重置更早的账号;只有一项非零时,调大该系数不会改变排序。
|
||||
缺失或已过期的所选窗口不加分,不回退到未启用窗口。同分时依次比较并发占用、上次使用时间和账号 ID。
|
||||
读取设置额外返回只读 `quotaResetWindowWeightsDefaults`,内容为上述全零对象,更新时不可提交该只读字段
|
||||
|
||||
两种策略均在没有可用亲和时,于最高可用权重层内选择账号,继续遵守账号资格、额度和并发限制。
|
||||
原生续写账号绑定仍是硬约束。
|
||||
配置随运行设置原子保存和发布,新请求使用新值,已开始请求及其重试沿用原快照,无需重启
|
||||
|
||||
### 模型定价
|
||||
@@ -2427,7 +2449,8 @@ models.dev 同步只导入可表示为当前文本 Token 计价的 OpenAI/xAI
|
||||
|
||||
`openaiClientProfile` 保存通用选择,首次默认 `MacOS · Desktop · 自动最新`。
|
||||
兼容字段的更新语义见上节。初始化不读取 YAML 身份字段。
|
||||
该配置作用于 Client Key 的 OpenAI 模型请求,适用于 HTTP/SSE、WebSocket、Images 和 Search。
|
||||
该配置作用于 Client Key 的 OpenAI 模型请求,适用于 HTTP/SSE、WebSocket、Images 和 Search,
|
||||
也用于账号模型目录的后台发现、手动刷新、导出及定时预热;下次执行时采用当前全局选择,不使用单个 Key 的覆盖。
|
||||
不改变 xAI、入站客户端版本门禁、账号认证或后台 Desktop 专属操作
|
||||
|
||||
自定义配置使用 `{ "mode": "custom", "userAgent": "完整 UA" }`。
|
||||
@@ -2463,13 +2486,14 @@ TUI 默认标识为 `codex-tui`,Exec 为 `codex_exec`,入口后缀使用同
|
||||
因此 Desktop 预设保持默认即可;CLI 预设建议配置真实值,多 Key 可通过各自的画像覆盖差异化
|
||||
|
||||
`versionLag` 让 `latest` 模式跟随官方发布但滞后 N 个已观察版本采用,省略时采用最新版本。
|
||||
档位基于网关观察到的发布序列解析:启动种子与历次 24 小时检查的核验版本按时间倒序构成历史,
|
||||
档位基于网关观察到的发布序列解析:启动种子与历次检查的核验版本按时间倒序构成历史,
|
||||
取第 N 项;序列不足时回退最旧已核验版本,不会因此解析失败。历史仅保留在进程内,
|
||||
重启后从启动种子与制品缓存重新积累
|
||||
|
||||
六套预设均支持自动更新:macOS Desktop 支持 arm64,Windows/Linux Desktop 及三套 CLI 支持 arm64、x86_64。
|
||||
预设接口的 `automaticAvailable`、`reason` 表示当前组合的可用性;自定义架构可能使自动解析不可用。
|
||||
每 24 小时后台检查官方稳定发布,失败保留同组合上次有效版本;固定值不受后台更新影响。
|
||||
启动时立即检查官方稳定发布,之后每轮检查完成等待 1 小时再检查。
|
||||
版本变化后提取并更新画像,失败保留同组合上次有效版本,下一轮重试;固定值不受后台更新影响。
|
||||
Desktop 的应用版本、Core 和构建号来自同一平台、架构的官方制品:macOS ZIP、Windows MSIX、Linux DEB。
|
||||
Windows/Linux 通过 ETag 检查更新,未变化时复用已核验版本;CLI 依据官方 npm 稳定标签和对应平台依赖
|
||||
|
||||
@@ -2480,6 +2504,7 @@ Windows/Linux 通过 ETag 检查更新,未变化时复用已核验版本;CLI
|
||||
完整自定义配置不携带官方制品核验时间。
|
||||
客户端画像配置控制应用层请求字段,不切换操作系统的 TLS 实现。默认 HTTP 使用 native TLS,
|
||||
WebSocket 使用 rustls;配置自定义 CA 时 HTTP 也使用 rustls。TLS 指纹需按实际部署平台与传输路径核验。
|
||||
版本未变化时只更新 `checkedAt`,保留 `verifiedAt`;缓存续期不改写核验时间。
|
||||
未完成本次启动检查时 `checkedAt` 为 `null`。非法或当前不可用的选择返回 `400`,保存失败不提交其他修改
|
||||
|
||||
Responses 的自动 Desktop Git 上下文与请求头使用同一画像快照:已有 `appServerVersion` 同步为 Core 版本,
|
||||
|
||||
+19
-8
@@ -531,6 +531,7 @@ OpenAI 的连接池监督该取消信号,按当前归属保护绑定连接;
|
||||
重新绑定或切到 HTTP 时移除失去用途的旧连接,失效 reservation 不能重新归池。
|
||||
普通空闲期限复用池槽位的 `idle_since`,只在归池时重置;心跳不刷新业务空闲,建连与在途不参与空闲回收。
|
||||
回收先移出可复用集合,再在锁外有界关闭并等待 pump/socket 释放,物理容量随 socket 归还;批量关闭并行执行。
|
||||
上游转发等待下游消费时仍响应连接取消和停机;终态先完成连接归还或销毁,再交付下游。
|
||||
Codex OAuth 上游 WS 在首个请求写入后记录搜索声明,握手完成但尚未发送请求的连接仍未初始化。
|
||||
后续首次声明搜索时,连接池回收不兼容的原连接;普通新链重新建连,连接内续接交由客户端完整重放。
|
||||
该判断共用于 HTTP 与 WS 入站,不修改客户端工具声明,也不保留对话正文。
|
||||
@@ -600,12 +601,16 @@ OpenAI 模型目录用于发现与原生 Responses 账号资格筛选。
|
||||
各 Provider 唯一负责默认值、校验、版本来源及 UA 生成,Admin 提供管理和生效预览。
|
||||
首次初始化只写入内置默认选择;YAML 不定义客户端身份,也不作为数据库初始化或请求解析的来源。
|
||||
官方发布资料与用户选择分开:OpenAI 在 Redis 按 Provider、客户端、平台、架构隔离可重建版本缓存,
|
||||
离线版本、制品身份及预设环境默认值集中在
|
||||
[`transport/profile/baseline.rs`](../backend/crates/providers/openai/src/transport/profile/baseline.rs),由发布检查与预设解析共用。
|
||||
Desktop 完整制品元组原子更新。CLI 的 TUI/Exec 入口共用官方 CLI 版本资料,Provider 在一次身份解析中
|
||||
生成一致的 UA、入口后缀与配套请求头,后台更新不修改用户选择的运行环境。
|
||||
完整自定义 UA 经 Provider 校验后原样传递,配套头统一解析;固定和自定义配置不受后台更新影响。
|
||||
OpenAI Provider 按 Key 种子、Key ID 与账号 ID 派生出站安装身份;未配置种子时使用账号身份,不改写账号凭据。
|
||||
普通连接按生效身份匹配,精确续写固定原连接与身份;配置合同见 [Key 客户端身份](api.md#key-客户端身份)。
|
||||
后台账号和 Desktop 专属操作使用独立官方 Desktop 画像,不接受 Key 覆盖。
|
||||
OpenAI 账号目录发现和定时预热每轮读取并解析一次当前全局画像,查询版本和请求头使用同一快照,不接受 Key 覆盖。
|
||||
其余后台账号和 Desktop 专属操作使用独立官方 Desktop 画像。
|
||||
管理端连接测试从本次发布快照携带全局画像,经 Provider 解析后冻结为探测身份。
|
||||
xAI 以内置画像为版本检查基线,在进程内更新 Grok CLI 发布资料;模型与压缩请求使用已保存的用户选择,
|
||||
OAuth、后台目录和额度查询使用内置官方画像。两者均不回写 `config.yaml`
|
||||
|
||||
@@ -658,9 +663,8 @@ OpenAI Provider 的账号资格模块统一解释请求类型、认证与套餐
|
||||
资格检查复用账号持久事实,在获取租约前与冻结的模型黑白名单共同过滤候选;亲和与重试沿用同一检查
|
||||
|
||||
原生 Responses 在评分、亲和和租约前检查冻结的账号模型政策。OpenAI 账号白名单精确命中目标 ID 时允许上游验证,
|
||||
其余 OpenAI 账号及 xAI 账号按有效目录排除未列出的模型。OpenAI 目录按来源账号、凭据版本和套餐隔离;同套餐账号可以有不同的模型。
|
||||
OpenAI 只使用未满 30 分钟且尚未收到变化通知的账号目录排除候选。大池可在读取账号时按目录摘要筛选,数据库逐账号核对版本、套餐和观测时间;白名单、待刷新通知及受管适配器不参与该筛选。xAI 按套餐去重读取 TTL 目录缓存,选号不请求上游目录。
|
||||
没有有效目录时保留上游验证,不从其他账号借用 OpenAI 模型资格,也不从其他套餐借用 xAI 模型资格
|
||||
其余原生 OpenAI 请求按来源账号、凭据版本和套餐匹配最近一次成功的目录,排除未列出的模型。大池可在读取账号时按目录摘要筛选,白名单和受管适配器由选号时单独判断。
|
||||
xAI 按套餐读取有效期内的目录缓存。两者在没有对应目录时保留上游验证,选号不请求上游目录
|
||||
|
||||
原生 OpenAI Responses 按[官方 Codex 0.166.0](https://github.com/openai/codex/blob/6ff1e1ca3b30fc8b914720681fcf5fe62e95f856/codex-rs/codex-api/src/error.rs#L73)的结构化 `model_not_found` 错误码与状态合同识别模型拒绝,
|
||||
不从消息或任意正文推断模型权限;通过既有模型级冷却端口记录账号、凭据版本与上游模型,30 分钟内不再选用该组合。
|
||||
@@ -674,9 +678,10 @@ OpenAI 只使用未满 30 分钟且尚未收到变化通知的账号目录排除
|
||||
### 智能调度
|
||||
|
||||
Core 定义、校验并统一拥有评分规则,内置选号与诊断复用同一函数;Store 随运行设置和配置 revision 原子保存,
|
||||
快照编译器将其纳入 `AccountSelectionPolicy`。近似最优容差随立即选号的有效系数总和缩放
|
||||
快照编译器将其纳入 `AccountSelectionPolicy`。智能调度混合各项评分,近似最优容差随立即选号的有效系数总和缩放
|
||||
|
||||
- 额度重置按 5 小时、周、月分别评分。Provider 复用已有额度快照的周期分类,只投影账号通用窗口。每个周期取最近的未来重置,以周期的七分之一为尺度 `H`,得分为 `H / (H + 剩余秒数)`。三个周期按所配系数取加权平均,缺失、未知或过期不加分,分母不随账号变化;三项默认为 0,此时重置不参与评分及容差计算
|
||||
- 额度重置按 5 小时、周、月分别评分。Provider 复用已有额度快照的周期分类,只投影账号通用窗口。每个周期取最近的未来重置,以周期的七分之一为尺度 `H`,得分为 `H / (H + 剩余秒数)`。三个周期按所配系数取加权平均,缺失、未知或过期不加分,分母不随账号变化。两种调度策略复用这一规则,分别保存窗口系数
|
||||
- 智能调度的窗口系数全为 0 时,重置不参与评分及容差计算。额度调度只按独立窗口系数比较重置分,严格选择最高分,不参与近似同分轮换;全零时沿用最早有效重置时间排序。同分继续按并发占用、上次使用时间和账号 ID 决定,资格、权重层和亲和约束保持在策略排序之前
|
||||
- 排队系数只在选择等待队列时结合其他评分和进程内实时等待人数,不影响立即选号分数与容差;系数为零时选最短队列。
|
||||
`ConcurrencyWaitQueue` 在同一锁内读取队长并入队,保持已有位置、同级 FIFO、取消回收、容量和共享等待预算;Provider 传入候选须已限定续写范围
|
||||
- 健康分按已发送尝试的结果计算账号级平滑失败率并随时间衰减;明确容量拒绝的平滑权重为 0.4,其他可计分失败和成功为 0.2
|
||||
@@ -729,6 +734,8 @@ OpenAI 固定归属请求直接读取目标账号,其余请求按冻结的账
|
||||
|
||||
Store 只保存带版本的绑定事实,Provider 在取得租约后、发送前原子认领、续期或按模式迁移;快照冲突释放租约并重新选择。
|
||||
首次认领不依赖根线程先发请求,独立后台任务也使用自身会话绑定。
|
||||
Messages 的 Claude Code 明确会话身份由 `gateway-protocol::anthropic` 解析,OpenAI Provider 在选号前按 Client Key 派生独立命名空间的亲和键,
|
||||
沿用现有绑定与调度策略;原生执行在 attempt 改写后、协议转换前复验身份,不建立 OpenAI 轮次关联或原生续接归属。
|
||||
OpenAI Provider 对无显式会话的 Responses 和 Chat Completions 入站请求,可按客户端缓存键或对话开头形成账号亲和。Messages 入站请求不按对话内容绑定账号。
|
||||
亲和键按 Client Key 隔离,与会话键使用不同命名空间,不建立轮次关联或原生续接归属。
|
||||
内容亲和存储不可用时,优先模式按普通调度继续选号,严格模式停止发送。
|
||||
@@ -968,8 +975,8 @@ PostgreSQL schema 由迁移目录按编号管理;冻结、升级与校验规
|
||||
### 账号模型目录
|
||||
|
||||
OpenAI 在 PostgreSQL 保存账号最近一次成功的模型目录、凭据版本、观测时间及 ETag。启动时批量恢复,按不同正文解析一次,保留每个账号的独立归属。没有历史目录也能发布路由快照;能力读取与推理不等待上游查询。
|
||||
后台只刷新目录缺失、已过刷新窗口或收到新 ETag 的账号;凭据轮换后按新版本重新发现。失败保留最后成功的结果,过期资料只用于展示,不能据此排除候选账号。
|
||||
新鲜度窗口、刷新并发与节奏由 [Provider 目录实现](../backend/crates/providers/openai/src/credential/catalog/mod.rs)统一维护
|
||||
后台刷新缺少目录、距上次成功观测已满 30 分钟或收到新 ETag 的账号。刷新期间及失败后继续使用上次成功的目录;凭据或套餐变化后不沿用旧目录。
|
||||
刷新并发与节奏由 [Provider 目录实现](../backend/crates/providers/openai/src/credential/catalog/mod.rs)统一维护
|
||||
|
||||
OpenAI 从账号目录生成原生列表;先按冻结政策选择来源,再读取本地账号状态核对凭据版本。同一份正文可以复用,但不会把一个账号的模型授予同套餐的其他账号。客户端版本和 Key 身份不触发额外发现
|
||||
|
||||
@@ -1293,6 +1300,10 @@ Worker 由各 Bundle 贡献、由 Host 统一监督:
|
||||
以及账号错误保护恢复 worker(到期解除或探测恢复)、重置卡自动使用和公共 CPR 互联同步
|
||||
- Provider:credential refresh、quota/catalog 健康、账号预热和官方版本/etag 检查
|
||||
|
||||
OpenAI 客户端画像由 Provider 每小时检查发布元数据,发布标识变化后才提取对应制品版本并发布画像。
|
||||
同版本的有效制品缓存每 24 小时续期,保留 30 天;续期保留原核验时间,失败不推进成功写入游标。
|
||||
版本及缓存更新失败保留当前画像,下轮继续尝试;Host 只监督调度与取消。
|
||||
|
||||
互联同步使用账号出口的受管 HTTP 客户端,不跟随跳转;网络等待不持有数据库事务。
|
||||
运行期排程、并发预算、连接失效和观测提交见 [CPR 互联观测](#cpr-互联观测),失败遵守退避及上游 `Retry-After`
|
||||
|
||||
|
||||
+4
-4
@@ -15,7 +15,7 @@
|
||||
设置保存在浏览器本地,不会同步到服务器或其他设备。只想换配色时,选择品牌色预置即可
|
||||
|
||||
下文说明实现和扩展方式。颜色使用 Ant Design 十阶色板与项目的明暗角色规则,
|
||||
中性表面从背景和文字 Seed 派生;Vue 组件通过 CSS Variables 与 Tailwind CSS 4 使用这些值。
|
||||
中性表面从当前底色和文字基色派生;Vue 组件通过 CSS Variables 与 Tailwind CSS 4 使用这些值。
|
||||
项目不依赖 Ant Design 组件库或 CSS-in-JS
|
||||
|
||||
> [!IMPORTANT]
|
||||
@@ -26,7 +26,7 @@
|
||||
|
||||
- **Seed 与 Map 可追踪**:主色和功能色均按 Ant Design 从 Seed 派生 P1-P10;浅色 P6 等于 Seed,深色 P6
|
||||
经过暗色色板适配。全局 `colorPrimary` 保留原始 Seed;功能色 Base 保留 P6。文字和按钮组件可在派生层做对比度校正,Seed 不随之改写
|
||||
- **主色与表面分离**:品牌色负责交互和强调,页面、容器、浮层与文字由独立的背景和文本 Seed 派生
|
||||
- **主色与表面分离**:品牌色负责交互和强调,页面、容器与浮层使用预设底色或自定义背景,文字由文本 Seed 派生
|
||||
- **语义独立**:成功、警告、错误、信息和链接色各自派生,不随品牌色改变
|
||||
- **无边设计**:默认依靠表面色差、间距和轻阴影表达层级;边框只用于焦点、错误和必要分隔
|
||||
- **运行时可定制**:用户输入在浏览器中实时派生,因此使用 CSS Variables,不使用构建时 SCSS 变量
|
||||
@@ -205,7 +205,7 @@ Preset 的实心色使用 P6,普通 Container、Strong Container 与边界按
|
||||
- `colorText / Heading / Secondary / Tertiary / Quaternary / Disabled`
|
||||
- `colorBorder / BorderSecondary / Split / Shadow`
|
||||
|
||||
所有品牌色共用当前明暗模式的背景和文字基色。手动设置 `colorBgBase` 或 `colorTextBase` 后,两个模式都使用该字段的自定义值;单项恢复后重新跟随明暗模式。
|
||||
编辑器中的背景和文字基色只随明暗模式或手动设置改变。未指定 `colorBgBase` 时,页面、卡片和浮层从当前预设的明暗底色派生;无预设底色时使用模式默认值。手动设置 `colorBgBase` 后,两个模式均以该值为底色,直至单项恢复
|
||||
默认浅色采用中性锚点,默认深色使用 HSL 色调派生;自定义中性色按外观距离平滑过渡到背景和文字 Seed 的 RGB 混色结果。
|
||||
Input、阴影与其他 Component Token 从 Fill、Surface、Primary 和 Semantic 派生,不在常量文件维护整套颜色表
|
||||
|
||||
@@ -449,7 +449,7 @@ utility / arbitrary variant;Vue Transition、跨浏览器 Range、动态富文
|
||||
单独增加品牌配色:
|
||||
|
||||
1. 在 `ThemeColorPresetId` 增加稳定 ID
|
||||
2. 在 `themeColorPresets` 声明名称、描述与主色 Seed
|
||||
2. 在 `themeColorPresets` 声明名称、描述与主色 Seed;需要独立底色时在 `PRESET_SURFACE_BACKGROUNDS` 中指定浅色和深色值
|
||||
3. 不新增页面特判,确认预置可通过同一 `createTheme()` 派生
|
||||
4. 在浅色、深色和系统模式下检查文本、浮层、Input、表格与图表
|
||||
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user