fix(admin): simplify account error messages

Co-authored-by: Codex <noreply@openai.com>
This commit is contained in:
Zyy
2026-11-20 10:43:53 +08:00
co-authored by Codex
parent 7c2c532b44
commit f8fa386a7e
14 changed files with 183 additions and 296 deletions
@@ -267,7 +267,7 @@ impl SettingsService for DefaultSettingsService {
)
})
{
return Err(AdminError::invalid("xAI 不支持此价格档位"));
return Err(AdminError::invalid("当前平台不支持此价格档位"));
}
if !pricing.bands.contains_key("standard")
&& command
@@ -107,8 +107,7 @@ async fn openai_import_should_expose_only_explicit_public_errors_without_committ
] {
let events = events();
let provider = FakeProviderAdmin::new("openai", events.clone());
provider
.fail_next_with_public_message(provider_kind, "Codex PAT 验证失败,请检查令牌后重试");
provider.fail_next_with_public_message(provider_kind, "PAT 验证失败,请检查令牌");
let store = FakeAccountStore::new("openai", events.clone());
let services = service(provider, store.clone()).await;
let error = services
@@ -124,7 +123,7 @@ async fn openai_import_should_expose_only_explicit_public_errors_without_committ
.await
.expect_err("validation must fail before committing accounts");
assert_eq!(error.kind(), admin_kind);
assert_eq!(error.to_string(), "Codex PAT 验证失败,请检查令牌后重试");
assert_eq!(error.to_string(), "PAT 验证失败,请检查令牌");
assert!(!format!("{error:?}").contains("secret token"));
assert_eq!(recorded(&events), ["provider.prepare_import"]);
assert!(store.audit_requests().is_empty());
@@ -442,29 +442,14 @@ mod provider {
*fixture.account.lock().unwrap() = Some(account(provider));
for (kind, status, code, message) in [
(Kind::Invalid, 400, 40001, "刷新令牌已被使用,请重新授权"),
(
Kind::Conflict,
409,
40901,
"令牌刷新繁忙,请等待当前刷新完成后重试",
),
(
Kind::BadGateway,
502,
50201,
"OpenAI 返回的 Codex PAT 身份资料不完整或格式无效,请稍后重试",
),
(
Kind::Unavailable,
503,
50301,
"暂时无法向 OpenAI 验证 Codex PAT,请稍后重试",
),
(Kind::Conflict, 409, 40901, "令牌刷新繁忙,请稍后重试"),
(Kind::BadGateway, 502, 50201, "PAT 身份信息无效"),
(Kind::Unavailable, 503, 50301, "PAT 验证服务暂不可用"),
(
Kind::Ambiguous,
502,
50202,
"令牌刷新结果未知,请先核对账号状态,不要立即重复刷新",
"刷新结果未知,核对账号状态前请勿重试",
),
] {
*fixture.provider_error.lock().unwrap() = Some(
+55 -118
View File
@@ -623,7 +623,7 @@ impl ProviderAdmin for OpenAiAdminProvider {
.map_err(map_store_error)?;
if !account_matches_record(&current.account, &command.account) {
return Err(provider_admin_error(ProviderAdminErrorKind::Conflict)
.with_public_message("账号凭据已被更新,请刷新账号列表后重试"));
.with_public_message("凭据已更新,请刷新账号列表"));
}
if current.account.authentication_kind()
== crate::credential::CODEX_AUTHENTICATION_KIND_API_KEY
@@ -686,7 +686,7 @@ impl ProviderAdmin for OpenAiAdminProvider {
.map_err(map_store_error)?;
if !account_matches_record(&current.account, &command.account) {
return Err(provider_admin_error(ProviderAdminErrorKind::Conflict)
.with_public_message("账号凭据已被更新,请刷新账号列表后重试"));
.with_public_message("凭据已更新,请刷新账号列表"));
}
let prepared = self
.credentials
@@ -974,7 +974,7 @@ impl ProviderAdmin for OpenAiAdminProvider {
for model in &models {
if model.document().protocol() != "codex" {
return Err(provider_admin_error(ProviderAdminErrorKind::Unsupported)
.with_public_message("该账号没有可导出的 Codex 原生模型目录"));
.with_public_message("该账号没有可导出的模型目录"));
}
let entry: serde_json::Value = serde_json::from_slice(model.document().body())
.map_err(|_| provider_admin_error(ProviderAdminErrorKind::Internal))?;
@@ -1772,53 +1772,33 @@ fn map_credential_admin_error(error: CodexCredentialAdminError) -> ProviderAdmin
Error::PersonalAccessToken(error) => match error {
PersonalAccessTokenError::InvalidToken => (
Kind::Invalid,
"Codex PAT 格式无效:应为 at- 开头的完整令牌,不能包含空白或控制字符",
),
PersonalAccessTokenError::Rejected => (
Kind::Invalid,
"OpenAI 拒绝了 Codex PAT:令牌可能无效、已过期、已撤销或没有访问权限",
),
PersonalAccessTokenError::Unavailable => (
Kind::Unavailable,
"暂时无法向 OpenAI 验证 Codex PAT,请稍后重试",
),
PersonalAccessTokenError::InvalidResponse => (
Kind::BadGateway,
"OpenAI 返回的 Codex PAT 身份资料不完整或格式无效,请稍后重试",
"请输入完整 PAT,以 at- 开头且不含空白或控制字符",
),
PersonalAccessTokenError::Rejected => (Kind::Invalid, "PAT 被拒绝,请检查令牌和权限"),
PersonalAccessTokenError::Unavailable => (Kind::Unavailable, "PAT 验证服务暂不可用"),
PersonalAccessTokenError::InvalidResponse => (Kind::BadGateway, "PAT 身份信息无效"),
},
Error::InvalidInput => (Kind::Invalid, "Codex 账号输入格式不合法,请检查导入内容"),
Error::InvalidCredential => (
Kind::Invalid,
"OpenAI 凭据不完整或格式无效,请检查凭据或重新授权",
),
Error::InvalidInput => (Kind::Invalid, "账号数据格式无效"),
Error::InvalidCredential => (Kind::Invalid, "凭据无效,请更正或重新授权"),
Error::MissingRefreshToken => (Kind::Invalid, "账号没有刷新令牌,请重新授权"),
Error::RefreshRejected { code, .. } => (
Kind::Invalid,
refresh_rejection_message(code.as_deref()).unwrap_or("刷新令牌已失效,请重新授权"),
),
Error::AccountBanned { .. } => (Kind::Invalid, "Codex 账号已被停用,请检查账号状态"),
Error::NotFound => (Kind::NotFound, "Codex 账号不存在,请刷新账号列表"),
Error::RefreshLeaseUnavailable => {
(Kind::Conflict, "令牌刷新繁忙,请等待当前刷新完成后重试")
}
Error::RefreshUnavailable => (
Kind::Unavailable,
"令牌刷新服务暂不可用,请检查出站连接与依赖服务",
),
Error::AccountBanned { .. } => (Kind::Invalid, "上游账号已停用"),
Error::NotFound => (Kind::NotFound, "账号不存在,请刷新列表"),
Error::RefreshLeaseUnavailable => (Kind::Conflict, "令牌刷新繁忙,请稍后重试"),
Error::RefreshUnavailable => (Kind::Unavailable, "令牌刷新服务暂不可用"),
Error::RefreshUpstream { status, code, .. } => (
Kind::BadGateway,
refresh_rejection_message(code.as_deref()).unwrap_or(match status {
401 | 403 => "OpenAI 拒绝了令牌刷新,请检查账号授权状态",
429 => "OpenAI 令牌刷新请求被限流,请稍后重试",
500..=599 => "OpenAI 令牌刷新服务异常,请稍后重试",
_ => "OpenAI 未能完成令牌刷新,请检查账号授权与上游服务状态",
401 | 403 => "令牌刷新被拒绝,请检查账号授权",
429 => "令牌刷新过于频繁,请稍后重试",
500..=599 => "令牌刷新服务异常,请稍后重试",
_ => "令牌刷新失败",
}),
),
Error::RefreshAmbiguous { .. } => (
Kind::Ambiguous,
"令牌刷新结果未知,请先核对账号状态,不要立即重复刷新",
),
Error::RefreshAmbiguous { .. } => (Kind::Ambiguous, "刷新结果未知,核对账号状态前请勿重试"),
};
let error = provider_admin_error(kind).with_public_message(public_message);
match upstream_message {
@@ -1835,7 +1815,7 @@ fn refresh_rejection_message(code: Option<&str>) -> Option<&'static str> {
Some("refresh_token_invalidated") => Some("刷新令牌已被撤销,请重新授权"),
// token_expired 也用于 RT 校验失败,不据此断言具体到期原因
Some("token_expired") => Some("刷新令牌不可用,请重新授权"),
Some("invalid_grant") => Some("刷新令牌无效或已失效,请重新授权"),
Some("invalid_grant") => Some("刷新令牌无效,请重新授权"),
_ => None,
}
}
@@ -1885,41 +1865,25 @@ fn map_oauth_error(error: CodexOAuthAdminError) -> ProviderAdminError {
use CodexOAuthAdminError as Error;
use ProviderAdminErrorKind as Kind;
let (kind, message) = match &error {
Error::InvalidInput => (Kind::Invalid, "OpenAI 授权参数不合法,请重新发起授权"),
Error::CallbackRejected => (Kind::Invalid, "OpenAI 授权回调校验失败,请重新发起授权"),
Error::InvalidInput => (Kind::Invalid, "授权参数无效,请重新授权"),
Error::CallbackRejected => (Kind::Invalid, "授权回调校验失败,请重新授权"),
Error::TokenRejected | Error::Exchange(Exchange::Rejected) => {
(Kind::Invalid, "OpenAI 拒绝了授权码,请重新发起授权")
(Kind::Invalid, "授权码被拒绝,请重新授权")
}
Error::Credential => (Kind::Invalid, "授权返回的凭据无效"),
Error::NotFound | Error::FlowExpired => (Kind::NotFound, "授权流程已失效,请重新授权"),
Error::Conflict => (Kind::Conflict, "授权状态冲突,请核对账号状态"),
Error::Exchange(Exchange::Ambiguous { .. }) => {
(Kind::Ambiguous, "授权结果未知,核对账号状态前请勿重试")
}
Error::Credential => (Kind::Invalid, "OpenAI 授权返回的凭据不完整或无效"),
Error::NotFound | Error::FlowExpired => (
Kind::NotFound,
"OpenAI 授权流程不存在或已过期,请重新发起授权",
),
Error::Conflict => (
Kind::Conflict,
"OpenAI 授权流程正在处理或已被更新,请先检查授权状态",
),
Error::Exchange(Exchange::Ambiguous { .. }) => (
Kind::Ambiguous,
"OpenAI 授权结果未知,请先核对账号状态,不要立即重复提交",
),
Error::Exchange(Exchange::Connection {
timed_out: true, ..
}) => (
Kind::Unavailable,
"连接 OpenAI 授权服务超时,请检查出站连接",
),
}) => (Kind::Unavailable, "连接授权服务超时,请检查出站连接"),
Error::Exchange(Exchange::Connection {
timed_out: false, ..
}) => (
Kind::Unavailable,
"无法连接 OpenAI 授权服务,请检查出站连接",
),
Error::Exchange(Exchange::Unavailable) => (
Kind::Unavailable,
"OpenAI 授权服务暂不可用,请检查出站连接后重试",
),
Error::StorageUnavailable => (Kind::Unavailable, "OpenAI 授权状态存储暂不可用,请稍后重试"),
}) => (Kind::Unavailable, "无法连接授权服务,请检查出站连接"),
Error::Exchange(Exchange::Unavailable) => (Kind::Unavailable, "授权服务暂不可用"),
Error::StorageUnavailable => (Kind::Unavailable, "授权状态存储暂不可用"),
};
provider_admin_error(kind)
.with_public_message(message)
@@ -1955,28 +1919,14 @@ fn map_quota_error(error: CodexCredentialQuotaError) -> ProviderAdminError {
let (kind, public_message, upstream_message) = match error {
Error::Profile(source) => {
return provider_admin_error(Kind::Unavailable)
.with_public_message("OpenAI 账号预热客户端身份不可用")
.with_public_message("预热客户端身份不可用")
.with_source(source);
}
Error::InvalidCredentialData => (
Kind::Invalid,
"OpenAI 额度查询凭据无效,请检查账号授权",
None,
),
Error::NotFound => (Kind::NotFound, "Codex 额度查询账号不存在", None),
Error::RevisionConflict => (
Kind::Conflict,
"账号凭据已被更新,请刷新账号列表后重试",
None,
),
Error::CredentialRefreshRequired => (
Kind::Unavailable,
"OpenAI 额度查询需要有效凭据,请刷新令牌后重试",
None,
),
Error::Repository(_) | Error::Store { .. } => {
(Kind::Unavailable, "OpenAI 额度查询的依赖服务暂不可用", None)
}
Error::InvalidCredentialData => (Kind::Invalid, "凭据或额度数据无效", None),
Error::NotFound => (Kind::NotFound, "账号不存在", None),
Error::RevisionConflict => (Kind::Conflict, "凭据已更新,请刷新账号列表", None),
Error::CredentialRefreshRequired => (Kind::Unavailable, "请先刷新令牌", None),
Error::Repository(_) | Error::Store { .. } => (Kind::Unavailable, "额度查询暂不可用", None),
Error::Upstream {
status,
code,
@@ -1985,24 +1935,14 @@ fn map_quota_error(error: CodexCredentialQuotaError) -> ProviderAdminError {
// 公开文案只解释已知状态和错误码;原始上游材料留在内部诊断,
// 额度查询拒绝不作为凭据失效证据,也不写入账号的凭据错误字段
let (kind, public_message) = match (status, code.as_deref()) {
(Some(401), Some("token_revoked")) => (
Kind::BadGateway,
"OpenAI 拒绝了额度查询(HTTP 401,token_revoked):访问令牌已被撤销,请刷新令牌或重新授权",
),
(Some(401), _) => (
Kind::BadGateway,
"OpenAI 拒绝了额度查询(HTTP 401),请检查账号授权状态;若令牌已在服务端失效,请重新授权",
),
(Some(403), _) => (
Kind::BadGateway,
"OpenAI 拒绝了额度查询(HTTP 403),请检查账号授权状态",
),
(Some(429), _) => (Kind::BadGateway, "OpenAI 额度查询被限流,请稍后重试"),
(Some(500..=599), _) => (Kind::BadGateway, "OpenAI 额度查询服务异常,请稍后重试"),
_ => (
Kind::Unavailable,
"OpenAI 额度查询失败,请检查出站连接与上游服务",
),
(Some(401), Some("token_revoked")) => {
(Kind::BadGateway, "访问令牌已撤销,请刷新令牌或重新授权")
}
(Some(401), _) => (Kind::BadGateway, "账号认证失败,请检查授权状态"),
(Some(403), _) => (Kind::BadGateway, "额度查询被拒绝,请检查账号权限"),
(Some(429), _) => (Kind::BadGateway, "额度查询过于频繁,请稍后重试"),
(Some(500..=599), _) => (Kind::BadGateway, "额度服务异常,请稍后重试"),
_ => (Kind::Unavailable, "额度查询失败"),
};
let upstream_message =
format!("OpenAI 额度查询失败:上游 HTTP {status:?},code = {code:?}:{detail}");
@@ -2027,7 +1967,7 @@ fn map_profile_statistics_error(error: CodexProfileStatisticsError) -> ProviderA
}
Error::CredentialRefreshRequired { upstream_body } => {
let mut error = provider_admin_error(ProviderAdminErrorKind::CredentialRefreshRequired)
.with_public_message("OpenAI 资料查询需要有效凭据,请刷新令牌后重试");
.with_public_message("请先刷新令牌");
if let Some(body) = upstream_body {
error = error.with_message(format!(
"OpenAI profile-statistics upstream returned HTTP 401: {}",
@@ -2045,7 +1985,7 @@ fn map_profile_statistics_error(error: CodexProfileStatisticsError) -> ProviderA
.map(|seconds| format!("; retry-after={seconds}s"))
.unwrap_or_default();
provider_admin_error(ProviderAdminErrorKind::BadGateway)
.with_public_message("OpenAI 资料查询失败,请检查账号授权与上游服务")
.with_public_message("资料查询失败")
.with_message(format!(
"OpenAI profile-statistics upstream returned HTTP {status}{retry_after}: {}",
bounded_upstream_body(&body)
@@ -2123,18 +2063,15 @@ fn map_catalog_error(error: CodexCredentialCatalogError) -> ProviderAdminError {
use CodexCredentialCatalogError as Error;
use ProviderAdminErrorKind as Kind;
let (kind, message) = match error {
Error::InvalidCredentialData => (Kind::Invalid, "OpenAI 模型查询凭据无效,请检查账号授权"),
Error::InvalidEtag => (Kind::Invalid, "OpenAI 模型目录版本标识无效,请重新查询"),
Error::NoEligibleCredential => (Kind::NotFound, "没有可用于查询 OpenAI 模型的账号"),
Error::ConcurrentUpdate => (Kind::Conflict, "OpenAI 模型目录正在更新,请稍后重试"),
Error::Upstream { .. } => (
Kind::Unavailable,
"OpenAI 模型查询失败,请检查出站连接与上游服务",
),
Error::Cache => (Kind::Unavailable, "OpenAI 模型目录缓存暂不可用"),
Error::InvalidCredentialData => (Kind::Invalid, "查询模型的凭据无效,请检查账号授权"),
Error::InvalidEtag => (Kind::Invalid, "模型目录版本无效,请重新查询"),
Error::NoEligibleCredential => (Kind::NotFound, "没有可查询模型的账号"),
Error::ConcurrentUpdate => (Kind::Conflict, "模型目录正在更新,请稍后重试"),
Error::Upstream { .. } => (Kind::Unavailable, "模型查询失败"),
Error::Cache => (Kind::Unavailable, "模型目录缓存暂不可用"),
Error::Profile(source) => {
return provider_admin_error(Kind::Unavailable)
.with_public_message("OpenAI 模型目录客户端身份不可用")
.with_public_message("模型目录客户端身份不可用")
.with_source(source);
}
};
@@ -380,9 +380,7 @@ impl AuthorizationCommitGuard for CodexOAuthAuthorizationCommitGuard {
if consumed {
Ok(())
} else {
Err(AdminError::conflict(
"OpenAI OAuth pending claim is no longer current",
))
Err(AdminError::conflict("授权状态已变更,请核对账号状态"))
}
}
@@ -396,7 +394,7 @@ impl AuthorizationCommitGuard for CodexOAuthAuthorizationCommitGuard {
Ok(())
} else {
Err(AdminError::unavailable(
"OpenAI 授权处理状态暂时无法释放,请先检查授权状态",
"授权流程未正常结束,请核对账号状态",
))
}
}
@@ -876,11 +874,9 @@ fn map_authorization_settlement_error(error: CodexOAuthPendingStoreError) -> Adm
AdminError::internal("OpenAI OAuth pending claim is invalid")
}
CodexOAuthPendingStoreError::Conflict => {
AdminError::conflict("OpenAI OAuth pending claim conflicts with current state")
}
CodexOAuthPendingStoreError::Unavailable => {
AdminError::unavailable("OpenAI 授权状态存储暂不可用,请稍后重试")
AdminError::conflict("授权状态冲突,请核对账号状态")
}
CodexOAuthPendingStoreError::Unavailable => AdminError::unavailable("授权状态存储暂不可用"),
}
}
@@ -145,9 +145,11 @@ impl ScheduledTask for OpenAiOAuthRefreshTask {
if context.cancellation().is_cancelled() {
return Ok(());
}
let outcomes = self.service.refresh_due().await.map_err(|error| {
WorkerTaskError::safe("OpenAI OAuth refresh failed").with_source(error)
})?;
let outcomes = self
.service
.refresh_due()
.await
.map_err(|error| WorkerTaskError::safe("令牌刷新失败").with_source(error))?;
let mut changed = Vec::new();
let mut refreshed = 0_u64;
let mut invalidated = 0_u64;
@@ -191,14 +193,12 @@ impl ScheduledTask for OpenAiOAuthRefreshTask {
.into_iter()
.map(|id| gateway_core::account::ProviderAccountId::new(id.as_str()))
.collect::<Result<Vec<_>, _>>()
.map_err(|error| {
WorkerTaskError::safe("OpenAI 账号 ID 无效").with_source(error)
})?;
.map_err(|error| WorkerTaskError::safe("账号 ID 无效").with_source(error))?;
self.catalog
.invalidate_accounts(&ids)
.await
.map_err(|error| {
WorkerTaskError::safe("OpenAI 凭据变更后目录失效失败").with_source(error)
WorkerTaskError::safe("凭据已更新,模型目录缓存清理失败").with_source(error)
})?;
}
if !outcomes.is_empty() {
@@ -288,8 +288,7 @@ impl ScheduledTask for OpenAiQuotaTask {
}
Ok(_) => {}
Err(error) => {
return Err(WorkerTaskError::safe("OpenAI quota synchronization failed")
.with_source(error));
return Err(WorkerTaskError::safe("额度同步失败").with_source(error));
}
}
Ok(())
@@ -305,10 +304,7 @@ impl ScheduledTask for OpenAiCatalogTask {
}
let result = match self.catalog.refresh_catalogs().await {
Ok(_) | Err(CodexCredentialCatalogError::NoEligibleCredential) => Ok(()),
Err(error) => Err(WorkerTaskError::safe(
"OpenAI model catalog synchronization failed",
)
.with_source(error)),
Err(error) => Err(WorkerTaskError::safe("模型目录同步失败").with_source(error)),
};
// 成功周期尾部追加 [0, 20%) 单侧随机抖动,打破固定周期轮询特征;
// 放在周期尾部避免延迟冷启动首轮刷新,失败路径交给宿主退避不叠加。
@@ -345,9 +341,7 @@ impl DaemonTask for OpenAiCatalogEtagTask {
Ok(_) | Err(CodexCredentialCatalogError::NoEligibleCredential) => {}
Err(error) => {
self.catalog.schedule_refresh();
return Err(
WorkerTaskError::safe("OpenAI 模型目录刷新失败").with_source(error)
);
return Err(WorkerTaskError::safe("模型目录刷新失败").with_source(error));
}
}
context.succeeded();
@@ -429,9 +423,7 @@ impl OpenAiWarmupTask {
.runtime_policy()
.load_warmup_policy()
.await
.map_err(|error| {
WorkerTaskError::safe("OpenAI warmup policy load failed").with_source(error)
})?;
.map_err(|error| WorkerTaskError::safe("预热策略加载失败").with_source(error))?;
if !policy.enabled() {
return Ok(());
}
@@ -450,21 +442,19 @@ impl OpenAiWarmupTask {
.naive_local()
.with_second(0)
.and_then(|value| value.with_nanosecond(0))
.ok_or_else(|| WorkerTaskError::safe("invalid warmup slot"))?;
.ok_or_else(|| WorkerTaskError::safe("预热时间无效"))?;
if !policy.matches_slot(slot) {
return Ok(());
}
let Some(model) = policy.model() else {
return Err(WorkerTaskError::safe("OpenAI warmup model is missing"));
return Err(WorkerTaskError::safe("未设置预热模型"));
};
if !self
.quota
.runtime_policy()
.claim_warmup_slot(self.timezone, slot)
.await
.map_err(|source| {
WorkerTaskError::safe("warmup slot is unavailable").with_source(source)
})?
.map_err(|source| WorkerTaskError::safe("无法领取本次预热任务").with_source(source))?
{
return Ok(());
}
@@ -931,9 +931,9 @@ async fn oauth_connection_failures_preserve_safe_diagnostics_and_release_the_cla
assert_eq!(
error.public_message(),
Some(if timed_out {
"连接 OpenAI 授权服务超时,请检查出站连接"
"连接授权服务超时,请检查出站连接"
} else {
"无法连接 OpenAI 授权服务,请检查出站连接"
"无法连接授权服务,请检查出站连接"
}),
);
let mut source = error.source();
@@ -1976,7 +1976,7 @@ async fn initialized_provider_reports_a_safe_pat_format_error_before_network_acc
assert_eq!(error.kind(), ProviderAdminErrorKind::Invalid);
assert_eq!(
error.public_message(),
Some("Codex PAT 格式无效:应为 at- 开头的完整令牌,不能包含空白或控制字符")
Some("请输入完整 PAT,以 at- 开头且不含空白或控制字符")
);
assert!(error.message().is_none());
assert!(!format!("{error:?}").contains("sensitive-token"));
@@ -2597,6 +2597,41 @@ mod errors {
use super::*;
#[tokio::test]
async fn expired_token_prompts_refresh_before_quota_and_profile_queries() {
let store = Arc::new(MemoryAccountStore::default());
let account_id = ProviderAccountId::new("acct_expired").unwrap();
let mut verified_account = profile("chatgpt-expired");
verified_account.access_token_expires_at = Some(Utc::now() - chrono::Duration::minutes(1));
store
.seed_oauth_credential(ImportCodexOAuthCredential {
account_id: account_id.as_str().to_owned(),
name: "expired".to_owned(),
secret: secret("expired-test-token"),
verified_account,
next_refresh_at: None,
enabled: true,
})
.await;
let server = MockServer::start().await;
let provider = initialized_test_bundle(store, server.uri())
.await
.admin_provider();
let quota_error = provider
.quota(ProviderQuotaRequest {
account_id: account_id.clone(),
refresh: true,
rolling_usage: None,
})
.await
.unwrap_err();
let profile_error = provider.profile_statistics(&account_id).await.unwrap_err();
for error in [quota_error, profile_error] {
assert_eq!(error.public_message(), Some("请先刷新令牌"));
}
assert!(server.received_requests().await.unwrap().is_empty());
}
#[tokio::test]
async fn quota_refresh_exposes_safe_failure_reasons_and_recovers_without_account_errors() {
let store = Arc::new(MemoryAccountStore::default());
@@ -2627,38 +2662,33 @@ mod errors {
401,
"token_revoked",
Kind::BadGateway,
"OpenAI 拒绝了额度查询(HTTP 401,token_revoked):访问令牌已被撤销,请刷新令牌或重新授权",
"访问令牌已撤销,请刷新令牌或重新授权",
),
(
401,
"unknown_code",
Kind::BadGateway,
"OpenAI 拒绝了额度查询(HTTP 401),请检查账号授权状态;若令牌已在服务端失效,请重新授权",
"账号认证失败,请检查授权状态",
),
(
403,
"forbidden",
Kind::BadGateway,
"OpenAI 拒绝了额度查询(HTTP 403),请检查账号授权状态",
"额度查询被拒绝,请检查账号权限",
),
(
429,
"rate_limited",
Kind::BadGateway,
"OpenAI 额度查询被限流,请稍后重试",
"额度查询过于频繁,请稍后重试",
),
(
503,
"unavailable",
Kind::BadGateway,
"OpenAI 额度查询服务异常,请稍后重试",
),
(
400,
"invalid_request",
Kind::Unavailable,
"OpenAI 额度查询失败,请检查出站连接与上游服务",
"额度服务异常,请稍后重试",
),
(400, "invalid_request", Kind::Unavailable, "额度查询失败"),
] {
server.reset().await;
Mock::given(method("GET"))
@@ -2711,12 +2741,8 @@ mod errors {
#[tokio::test]
async fn manual_refresh_preserves_banned_evidence_without_promoting_401_to_terminal() {
for (status, kind, message) in [
(400, Kind::Invalid, "Codex 账号已被停用,请检查账号状态"),
(
401,
Kind::BadGateway,
"OpenAI 拒绝了令牌刷新,请检查账号授权状态",
),
(400, Kind::Invalid, "上游账号已停用"),
(401, Kind::BadGateway, "令牌刷新被拒绝,请检查账号授权"),
] {
let server = MockServer::start().await;
Mock::given(method("POST"))
@@ -2776,7 +2802,7 @@ mod errors {
401,
"unknown",
Kind::BadGateway,
"OpenAI 拒绝了令牌刷新,请检查账号授权状态",
"令牌刷新被拒绝,请检查账号授权",
),
(
400,
@@ -2800,19 +2826,19 @@ mod errors {
400,
"INVALID_GRANT",
Kind::BadGateway,
"刷新令牌无效或已失效,请重新授权",
"刷新令牌无效,请重新授权",
),
(
429,
"unknown",
Kind::BadGateway,
"OpenAI 令牌刷新请求被限流,请稍后重试",
"令牌刷新过于频繁,请稍后重试",
),
(
503,
"unknown",
Kind::BadGateway,
"OpenAI 令牌刷新服务异常,请稍后重试",
"令牌刷新服务异常,请稍后重试",
),
] {
let server = MockServer::start().await;
@@ -2848,7 +2874,7 @@ mod errors {
true,
false,
Kind::Conflict,
"令牌刷新繁忙,请等待当前刷新完成后重试",
"令牌刷新繁忙,请稍后重试",
),
(
false,
@@ -2862,7 +2888,7 @@ mod errors {
true,
true,
Kind::Conflict,
"账号凭据已被更新,请刷新账号列表后重试",
"凭据已更新,请刷新账号列表",
),
] {
let server = MockServer::start().await;
@@ -2908,7 +2934,7 @@ mod errors {
assert_eq!(error.kind(), Kind::Ambiguous);
assert_eq!(
error.public_message(),
Some("令牌刷新结果未知,请先核对账号状态,不要立即重复刷新")
Some("刷新结果未知,核对账号状态前请勿重试")
);
assert!(!format!("{error:?}").contains("invalid-success-secret-marker"));
@@ -2928,7 +2954,7 @@ mod errors {
assert_eq!(error.kind(), Kind::Ambiguous);
assert_eq!(
error.public_message(),
Some("令牌刷新结果未知,请先核对账号状态,不要立即重复刷新")
Some("刷新结果未知,核对账号状态前请勿重试")
);
assert_eq!(store.account("acct_refresh_error").unwrap(), before);
}
+33 -70
View File
@@ -108,9 +108,9 @@ impl AuthorizationCommitGuard for XaiAuthorizationCommitGuard {
OAuthPendingConsumeOutcome::Consumed => Ok(()),
OAuthPendingConsumeOutcome::NotFound
| OAuthPendingConsumeOutcome::OwnerMismatch
| OAuthPendingConsumeOutcome::ClaimMismatch => Err(AdminError::conflict(
"xAI OAuth pending claim is no longer current",
)),
| OAuthPendingConsumeOutcome::ClaimMismatch => {
Err(AdminError::conflict("授权状态已变更,请核对账号状态"))
}
}
}
@@ -125,7 +125,7 @@ impl AuthorizationCommitGuard for XaiAuthorizationCommitGuard {
OAuthPendingReleaseOutcome::NotFound
| OAuthPendingReleaseOutcome::OwnerMismatch
| OAuthPendingReleaseOutcome::ClaimMismatch => Err(AdminError::unavailable(
"xAI 授权处理状态暂时无法释放,请先检查授权状态",
"授权流程未正常结束,请核对账号状态",
)),
}
}
@@ -723,7 +723,7 @@ impl ProviderAdmin for XaiAdminProvider {
.map_err(map_store_error)?;
if !account_matches_record(&current.account, &command.account) {
return Err(provider_error(ProviderAdminErrorKind::Conflict)
.with_public_message("账号凭据已被更新,请刷新账号列表后重试"));
.with_public_message("凭据已更新,请刷新账号列表"));
}
let rotation: RotationDocument = serde_json::from_value(Value::Object(
command.provider_material.into_provider_data().into_inner(),
@@ -777,7 +777,7 @@ impl ProviderAdmin for XaiAdminProvider {
.map_err(map_store_error)?;
if !account_matches_record(&current.account, &command.account) {
return Err(provider_error(ProviderAdminErrorKind::Conflict)
.with_public_message("账号凭据已被更新,请刷新账号列表后重试"));
.with_public_message("凭据已更新,请刷新账号列表"));
}
let prepared = self
.refresh
@@ -1470,24 +1470,13 @@ fn build_connection_test_operation(
fn map_failure_class(class: FailureClass) -> ProviderAdminError {
use ProviderAdminErrorKind as Kind;
let (kind, message) = match class {
FailureClass::Transient => (
Kind::Unavailable,
"xAI 授权服务暂不可用,请检查出站连接后重试",
),
FailureClass::Ambiguous => (
Kind::Ambiguous,
"xAI 授权结果未知,请先核对账号状态,不要立即重复提交",
),
FailureClass::CredentialPermanent => (Kind::Invalid, "xAI 拒绝了当前凭据,请检查账号授权"),
FailureClass::ConfigurationPermanent => {
(Kind::Invalid, "xAI 授权配置无效,请检查客户端与授权配置")
}
FailureClass::UserActionRequired => (Kind::Invalid, "xAI 授权需要用户确认,请重新完成授权"),
FailureClass::Security => (
Kind::Invalid,
"xAI 授权安全校验失败,请检查授权来源与账号信息",
),
FailureClass::Unsupported => (Kind::Unsupported, "xAI 不支持当前授权操作"),
FailureClass::Transient => (Kind::Unavailable, "授权服务暂不可用"),
FailureClass::Ambiguous => (Kind::Ambiguous, "授权结果未知,核对账号状态前请勿重试"),
FailureClass::CredentialPermanent => (Kind::Invalid, "凭据被拒绝,请检查账号授权"),
FailureClass::ConfigurationPermanent => (Kind::Invalid, "授权配置无效,请检查客户端配置"),
FailureClass::UserActionRequired => (Kind::Invalid, "请重新授权并确认"),
FailureClass::Security => (Kind::Invalid, "授权校验失败,请核对来源和账号"),
FailureClass::Unsupported => (Kind::Unsupported, "不支持此授权操作"),
};
provider_error(kind).with_public_message(message)
}
@@ -1509,12 +1498,8 @@ fn map_pending_claim_settlement_error(error: ProviderStoreError) -> AdminError {
ProviderStoreErrorKind::InvalidData => {
AdminError::internal("xAI OAuth pending claim is invalid")
}
ProviderStoreErrorKind::Conflict => {
AdminError::conflict("xAI OAuth pending claim conflicts with current state")
}
ProviderStoreErrorKind::Unavailable => {
AdminError::unavailable("xAI 授权状态存储暂不可用,请稍后重试")
}
ProviderStoreErrorKind::Conflict => AdminError::conflict("授权状态冲突,请核对账号状态"),
ProviderStoreErrorKind::Unavailable => AdminError::unavailable("授权状态存储暂不可用"),
}
}
@@ -1553,27 +1538,15 @@ fn map_refresh_error(error: GrokCredentialRefreshError) -> ProviderAdminError {
let (kind, message) = match error {
Error::Repository(error) => return map_repository_error(error),
Error::Lease(error) => return map_provider_store_error(error),
Error::LeaseBusy => (Kind::Conflict, "令牌刷新繁忙,请等待当前刷新完成后重试"),
Error::InvalidRefreshResponse => (
Kind::Ambiguous,
"xAI 返回的刷新凭据无效,请先核对账号状态,不要立即重复刷新",
),
Error::Preparation => (Kind::Unavailable, "xAI 令牌刷新服务尚未就绪,请稍后重试"),
Error::LeaseBusy => (Kind::Conflict, "令牌刷新繁忙,请稍后重试"),
Error::InvalidRefreshResponse => (Kind::Ambiguous, "新凭据无效,核对账号状态前请勿重试"),
Error::Preparation => (Kind::Unavailable, "令牌刷新服务尚未就绪"),
Error::ManualFailure(failure) => match failure {
Failure::Transient => (
Kind::Unavailable,
"xAI 令牌刷新连接失败,请检查出站连接后重试",
),
Failure::Ambiguous => (
Kind::Ambiguous,
"令牌刷新结果未知,请先核对账号状态,不要立即重复刷新",
),
Failure::Transient => (Kind::Unavailable, "无法连接令牌刷新服务,请检查出站连接"),
Failure::Ambiguous => (Kind::Ambiguous, "刷新结果未知,核对账号状态前请勿重试"),
Failure::InvalidGrant => (Kind::Invalid, "刷新令牌已失效,请重新授权"),
Failure::Banned => (Kind::Invalid, "xAI 账号已被停用,请检查账号状态"),
Failure::Rejected => (
Kind::BadGateway,
"xAI 未能完成令牌刷新,请检查授权配置与上游服务",
),
Failure::Banned => (Kind::Invalid, "上游账号已停用"),
Failure::Rejected => (Kind::BadGateway, "令牌刷新失败"),
},
};
provider_error(kind).with_public_message(message)
@@ -1583,16 +1556,11 @@ fn map_quota_error(error: GrokQuotaError) -> ProviderAdminError {
use GrokQuotaError as Error;
use ProviderAdminErrorKind as Kind;
let (kind, message) = match error {
Error::AccountUnavailable => (Kind::NotFound, "没有可用于查询 xAI 额度的账号"),
Error::StaleCredentialSnapshot => {
(Kind::Conflict, "账号凭据已被更新,请刷新账号列表后重试")
}
Error::InvalidData => (Kind::Invalid, "xAI 额度数据无效,请检查账号授权"),
Error::Upstream => (
Kind::Unavailable,
"xAI 额度查询失败,请检查出站连接与上游服务",
),
Error::Store => (Kind::Unavailable, "xAI 额度查询的依赖服务暂不可用"),
Error::AccountUnavailable => (Kind::NotFound, "当前账号无法查询额度"),
Error::StaleCredentialSnapshot => (Kind::Conflict, "凭据已更新,请刷新账号列表"),
Error::InvalidData => (Kind::Invalid, "凭据或额度数据无效"),
Error::Upstream => (Kind::Unavailable, "额度查询失败"),
Error::Store => (Kind::Unavailable, "额度查询暂不可用"),
};
provider_error(kind).with_public_message(message)
}
@@ -1601,17 +1569,12 @@ fn map_catalog_error(error: GrokCredentialCatalogError) -> ProviderAdminError {
use GrokCredentialCatalogError as Error;
use ProviderAdminErrorKind as Kind;
let (kind, message) = match error {
Error::InvalidCredentialData => (Kind::Invalid, "xAI 模型查询凭据无效,请检查账号授权"),
Error::ConflictingModelFacts => (Kind::Invalid, "xAI 模型目录信息不一致,请重新查询"),
Error::NoEligibleCredential => (Kind::NotFound, "没有可用于查询 xAI 模型的账号"),
Error::StaleCredentialSnapshot => {
(Kind::Conflict, "账号凭据已被更新,请刷新账号列表后重试")
}
Error::Upstream => (
Kind::Unavailable,
"xAI 模型查询失败,请检查出站连接与上游服务",
),
Error::Cache | Error::Store => (Kind::Unavailable, "xAI 模型查询的依赖服务暂不可用"),
Error::InvalidCredentialData => (Kind::Invalid, "查询模型的凭据无效,请检查账号授权"),
Error::ConflictingModelFacts => (Kind::Invalid, "模型目录不一致,请重新查询"),
Error::NoEligibleCredential => (Kind::NotFound, "没有可查询模型的账号"),
Error::StaleCredentialSnapshot => (Kind::Conflict, "凭据已更新,请刷新账号列表"),
Error::Upstream => (Kind::Unavailable, "模型查询失败"),
Error::Cache | Error::Store => (Kind::Unavailable, "模型查询暂不可用"),
};
provider_error(kind).with_public_message(message)
}
@@ -106,9 +106,11 @@ impl ScheduledTask for XaiOAuthRefreshTask {
if context.cancellation().is_cancelled() {
return Ok(());
}
let outcomes = self.service.refresh_due().await.map_err(|error| {
WorkerTaskError::safe("xAI OAuth refresh failed").with_source(error)
})?;
let outcomes = self
.service
.refresh_due()
.await
.map_err(|error| WorkerTaskError::safe("令牌刷新失败").with_source(error))?;
let failures = outcomes
.iter()
.filter(|outcome| {
@@ -150,9 +152,7 @@ impl ScheduledTask for XaiQuotaCatalogTask {
.accounts
.list_for_provider(&self.provider_kind)
.await
.map_err(|source| {
WorkerTaskError::safe("xAI Provider accounts unavailable").with_source(source)
})?;
.map_err(|source| WorkerTaskError::safe("账号列表读取失败").with_source(source))?;
let mut failures = QuotaCatalogFailure::default();
let now = SystemTime::now();
let accounts = self.reserve_periodic_refreshes(accounts, now);
@@ -175,10 +175,7 @@ impl ScheduledTask for XaiQuotaCatalogTask {
if failures.quota_failures == 0 && failures.catalog_error.is_none() {
Ok(())
} else {
Err(
WorkerTaskError::safe("xAI quota or catalog synchronization failed")
.with_source(failures),
)
Err(WorkerTaskError::safe("额度或模型目录同步失败").with_source(failures))
}
})
}
+5 -11
View File
@@ -211,7 +211,7 @@ async fn xai_quota_catalog_worker_preserves_store_failures() {
let error = run_quota_catalog_cycle(&mut bundle)
.await
.expect_err("Provider account Store failure");
assert_eq!(error.as_safe_str(), "xAI Provider accounts unavailable");
assert_eq!(error.as_safe_str(), "账号列表读取失败");
}
#[tokio::test]
@@ -250,10 +250,7 @@ async fn xai_quota_catalog_worker_retains_both_failure_stages_and_finishes_the_b
let error = run_quota_catalog_cycle(&mut bundle)
.await
.expect_err("invalid stored credentials");
assert_eq!(
error.as_safe_str(),
"xAI quota or catalog synchronization failed"
);
assert_eq!(error.as_safe_str(), "额度或模型目录同步失败");
let details = error.error_details().expect("synchronization causes");
let details: Value = serde_json::from_str(details.as_str()).unwrap();
let cause = details["causes"]["messages"][0].as_str().unwrap();
@@ -1245,7 +1242,7 @@ mod errors {
Some(if expired {
"刷新令牌已失效,请重新授权"
} else {
"账号凭据已被更新,请刷新账号列表后重试"
"凭据已更新,请刷新账号列表"
})
);
assert_eq!(store.account(&input.account_id).unwrap(), before);
@@ -1286,10 +1283,7 @@ mod errors {
.await
.unwrap_err();
assert_eq!(error.kind(), Kind::Conflict);
assert_eq!(
error.public_message(),
Some("令牌刷新繁忙,请等待当前刷新完成后重试")
);
assert_eq!(error.public_message(), Some("令牌刷新繁忙,请稍后重试"));
assert_eq!(
listener.accept().unwrap_err().kind(),
std::io::ErrorKind::WouldBlock
@@ -1322,7 +1316,7 @@ mod errors {
assert_eq!(error.kind(), Kind::Unavailable);
assert_eq!(
error.public_message(),
Some("xAI 令牌刷新连接失败,请检查出站连接后重试")
Some("无法连接令牌刷新服务,请检查出站连接")
);
assert!(!format!("{error:?} {error}").contains("proxy-secret-marker"));
assert_eq!(store.account(&input.account_id).unwrap(), before);
+1 -1
View File
@@ -308,7 +308,7 @@
"resetRefreshFailed": "Quota reset succeeded, but the latest quota could not be loaded: {value}",
"statusRestored": "Account status restored",
"staleAccount": "Account {id} is out of date, select it again",
"unsupportedProvider": "Unsupported provider: {provider}"
"deletionResultUnknown": "Deletion result unknown. Check the account list"
},
"usage": {
"call": "Calls",
@@ -308,7 +308,7 @@
"resetRefreshFailed": "额度已重置,但最新额度加载失败:{value}",
"statusRestored": "账号状态已恢复",
"staleAccount": "账号 {id} 的页面数据已失效,请重新选择",
"unsupportedProvider": "不支持的 Provider:{provider}"
"deletionResultUnknown": "删除结果未知,请核对账号列表"
},
"usage": {
"call": "调用",
@@ -308,7 +308,7 @@
"resetRefreshFailed": "額度已重置,但最新額度加載失敗:{value}",
"statusRestored": "賬號狀態已恢復",
"staleAccount": "賬號 {id} 的頁面數據已失效,請重新選擇",
"unsupportedProvider": "不支持的 Provider:{provider}"
"deletionResultUnknown": "刪除結果未知,請核對賬號列表"
},
"usage": {
"call": "調用",
@@ -333,7 +333,7 @@ export function useAccountMutations(options: {
}
const result = await deleteAccounts(payload, options)
if (!result)
throw new Error(t('accounts.actions.unsupportedProvider', { provider: account.provider }))
throw new Error(t('accounts.actions.deletionResultUnknown'))
}
function accountDeletionGroups(accounts: Account[]) {