diff --git a/desktop-tauri/i18n/i18n-src/en/settings.json b/desktop-tauri/i18n/i18n-src/en/settings.json index 7dc76c228..0d10cd574 100644 --- a/desktop-tauri/i18n/i18n-src/en/settings.json +++ b/desktop-tauri/i18n/i18n-src/en/settings.json @@ -464,7 +464,7 @@ "天数": "Days", "失败 {n} 个": "failed: {n}", "失败 {n} 个:{detail}": "Failed: {n}; {detail}", - "失败后最多再换几个账号试(填 N = 最多换 N 个,首发那个不算)。换到同一家名下另一个账号、或换到另一家,都各算一次;换满仍失败就返回错误。可填 0–10,0 表示失败立即报错。": "How many more accounts to try on failure (N = switch to at most N accounts; the account that made the first attempt does not count). Switching to another account under the same provider and switching to a different provider each count as one; once the limit is reached and the request still fails, an error is returned. Accepts 0–10; 0 means report the error immediately on failure.", + "失败后最多再换几个账号试(填 N = 最多换 N 个,首发那个不算)。换到同一家名下另一个账号、或换到另一家,都各算一次;换满仍失败就返回错误。可填 0–100,0 表示失败立即报错。": "How many more accounts to try on failure (N = switch to at most N accounts; the account that made the first attempt does not count). Switching to another account under the same provider and switching to a different provider each count as one; once the limit is reached and the request still fails, an error is returned. Accepts 0–100; 0 means report the error immediately on failure.", "如果主库已被替换到一半,替换前的数据在 backups/ 目录里仍可整文件拷回。": "", "存储桶(Bucket)": "Bucket", "存储概况已刷新": "Storage overview refreshed", diff --git a/desktop-tauri/i18n/i18n-src/ja/settings.json b/desktop-tauri/i18n/i18n-src/ja/settings.json index 90f4c3e6c..0271dcf1e 100644 --- a/desktop-tauri/i18n/i18n-src/ja/settings.json +++ b/desktop-tauri/i18n/i18n-src/ja/settings.json @@ -464,7 +464,7 @@ "天数": "日数", "失败 {n} 个": "失敗 {n} 件", "失败 {n} 个:{detail}": "失敗 {n} 件:{detail}", - "失败后最多再换几个账号试(填 N = 最多换 N 个,首发那个不算)。换到同一家名下另一个账号、或换到另一家,都各算一次;换满仍失败就返回错误。可填 0–10,0 表示失败立即报错。": "失敗後に最大であと何個のアカウントに切り替えて試すか(N を入力 = 最大 N 個まで切替。初回のアカウントは含みません)。同じプロバイダー配下の別のアカウントへの切替も、別のプロバイダーへの切替もそれぞれ 1 回と数えます。使い切ってもなお失敗する場合はエラーを返します。0–10 を入力でき、0 は失敗時に即座にエラーを返すことを意味します。", + "失败后最多再换几个账号试(填 N = 最多换 N 个,首发那个不算)。换到同一家名下另一个账号、或换到另一家,都各算一次;换满仍失败就返回错误。可填 0–100,0 表示失败立即报错。": "失敗後に最大であと何個のアカウントに切り替えて試すか(N を入力 = 最大 N 個まで切替。初回のアカウントは含みません)。同じプロバイダー配下の別のアカウントへの切替も、別のプロバイダーへの切替もそれぞれ 1 回と数えます。使い切ってもなお失敗する場合はエラーを返します。0–100 を入力でき、0 は失敗時に即座にエラーを返すことを意味します。", "如果主库已被替换到一半,替换前的数据在 backups/ 目录里仍可整文件拷回。": "", "存储桶(Bucket)": "バケット(Bucket)", "存储概况已刷新": "ストレージ概要を更新しました", diff --git a/desktop-tauri/i18n/i18n-src/ko/settings.json b/desktop-tauri/i18n/i18n-src/ko/settings.json index 19ae189b8..e3c837970 100644 --- a/desktop-tauri/i18n/i18n-src/ko/settings.json +++ b/desktop-tauri/i18n/i18n-src/ko/settings.json @@ -464,7 +464,7 @@ "天数": "일수", "失败 {n} 个": "실패 {n}개", "失败 {n} 个:{detail}": "실패 {n}개: {detail}", - "失败后最多再换几个账号试(填 N = 最多换 N 个,首发那个不算)。换到同一家名下另一个账号、或换到另一家,都各算一次;换满仍失败就返回错误。可填 0–10,0 表示失败立即报错。": "실패 후 최대 몇 개의 계정으로 더 시도할지 정합니다(N 입력 = 최대 N개 전환, 최초 계정은 제외). 같은 제공자의 다른 계정으로 바꾸거나 다른 제공자로 바꾸는 것 모두 1회로 계산하며, 횟수를 다 써도 실패하면 오류를 반환합니다. 0–10 입력 가능하며, 0이면 실패 시 즉시 오류를 반환합니다.", + "失败后最多再换几个账号试(填 N = 最多换 N 个,首发那个不算)。换到同一家名下另一个账号、或换到另一家,都各算一次;换满仍失败就返回错误。可填 0–100,0 表示失败立即报错。": "실패 후 최대 몇 개의 계정으로 더 시도할지 정합니다(N 입력 = 최대 N개 전환, 최초 계정은 제외). 같은 제공자의 다른 계정으로 바꾸거나 다른 제공자로 바꾸는 것 모두 1회로 계산하며, 횟수를 다 써도 실패하면 오류를 반환합니다. 0–100 입력 가능하며, 0이면 실패 시 즉시 오류를 반환합니다.", "如果主库已被替换到一半,替换前的数据在 backups/ 目录里仍可整文件拷回。": "", "存储桶(Bucket)": "버킷(Bucket)", "存储概况已刷新": "저장소 개요를 새로 고쳤습니다", diff --git a/desktop-tauri/i18n/i18n-src/pt-BR/settings.json b/desktop-tauri/i18n/i18n-src/pt-BR/settings.json index 0110dc778..a3731a26c 100644 --- a/desktop-tauri/i18n/i18n-src/pt-BR/settings.json +++ b/desktop-tauri/i18n/i18n-src/pt-BR/settings.json @@ -464,7 +464,7 @@ "天数": "Dias", "失败 {n} 个": "Falhas: {n}", "失败 {n} 个:{detail}": "Falhas: {n} — {detail}", - "失败后最多再换几个账号试(填 N = 最多换 N 个,首发那个不算)。换到同一家名下另一个账号、或换到另一家,都各算一次;换满仍失败就返回错误。可填 0–10,0 表示失败立即报错。": "Quantas contas a mais tentar em caso de falha (preencha N = trocar por até N contas; a que fez o primeiro envio não conta). Trocar para outra conta do mesmo provedor ou para outro provedor conta igualmente como uma troca; se o limite se esgotar e a falha persistir, um erro é retornado. Valores de 0–10; 0 significa retornar o erro imediatamente após a falha.", + "失败后最多再换几个账号试(填 N = 最多换 N 个,首发那个不算)。换到同一家名下另一个账号、或换到另一家,都各算一次;换满仍失败就返回错误。可填 0–100,0 表示失败立即报错。": "Quantas contas a mais tentar em caso de falha (preencha N = trocar por até N contas; a que fez o primeiro envio não conta). Trocar para outra conta do mesmo provedor ou para outro provedor conta igualmente como uma troca; se o limite se esgotar e a falha persistir, um erro é retornado. Valores de 0–100; 0 significa retornar o erro imediatamente após a falha.", "如果主库已被替换到一半,替换前的数据在 backups/ 目录里仍可整文件拷回。": "", "存储桶(Bucket)": "Bucket", "存储概况已刷新": "Visão geral do armazenamento atualizada", diff --git a/desktop-tauri/i18n/i18n-src/zh-Hant/settings.json b/desktop-tauri/i18n/i18n-src/zh-Hant/settings.json index 2c72815aa..33d0fe1f7 100644 --- a/desktop-tauri/i18n/i18n-src/zh-Hant/settings.json +++ b/desktop-tauri/i18n/i18n-src/zh-Hant/settings.json @@ -449,7 +449,7 @@ "天数": "", "失败 {n} 个": "", "失败 {n} 个:{detail}": "", - "失败后最多再换几个账号试(填 N = 最多换 N 个,首发那个不算)。换到同一家名下另一个账号、或换到另一家,都各算一次;换满仍失败就返回错误。可填 0–10,0 表示失败立即报错。": "", + "失败后最多再换几个账号试(填 N = 最多换 N 个,首发那个不算)。换到同一家名下另一个账号、或换到另一家,都各算一次;换满仍失败就返回错误。可填 0–100,0 表示失败立即报错。": "", "如果主库已被替换到一半,替换前的数据在 backups/ 目录里仍可整文件拷回。": "", "存储桶(Bucket)": "", "存储概况已刷新": "", diff --git a/desktop-tauri/src-tauri/Cargo.toml b/desktop-tauri/src-tauri/Cargo.toml index b663c520d..d846c2c32 100644 --- a/desktop-tauri/src-tauri/Cargo.toml +++ b/desktop-tauri/src-tauri/Cargo.toml @@ -9,6 +9,10 @@ edition = "2021" # 要求 1.88,会让「照着 rust-version 装旧工具链」的构建直接失败。 rust-version = "1.88" license = "AGPL-3.0-only" +# workspace 拆出 `server/` 之后本 crate 与它各有一个 bin,`tauri dev` 调的是 +# 裸 `cargo run`(不带 --bin):不指定 default-run 就会报 +# 「could not determine which binary to run」。桌面端是默认入口。 +default-run = "workbuddy-proxy-desktop" repository = "https://github.com/aimod-cc/Agent2API" homepage = "https://github.com/aimod-cc/Agent2API" diff --git a/desktop-tauri/src-tauri/server/src/lib.rs b/desktop-tauri/src-tauri/server/src/lib.rs index 5999290e3..014ac86a1 100644 --- a/desktop-tauri/src-tauri/server/src/lib.rs +++ b/desktop-tauri/src-tauri/server/src/lib.rs @@ -37,21 +37,44 @@ use std::sync::OnceLock; use tokio::runtime::{Handle, Runtime}; -/// 工作线程与阻塞池的栈大小(8 MiB): -/// Thin LTO / 调试构建下加载与执行 Wasm 插件会超出默认的 2 MiB 栈空间。 -pub const WORKER_STACK_BYTES: usize = 8 * 1024 * 1024; +/// 工作线程与阻塞池的栈大小(默认 32 MiB,可用环境变量覆盖): +/// Thin LTO / 调试构建下加载与执行 Wasm 插件会超出默认的 2 MiB 栈空间 +/// (`0xC00000FD STATUS_STACK_OVERFLOW`,注意这是**线程栈**不是堆内存, +/// 机器空闲也照崩)。 +/// +/// 实测记录(debug 构建): +/// * 2 MiB(默认)——插件的 `init` 直接打穿; +/// * 8 MiB ——启动期仍崩; +/// * 16 MiB ——`wasm modelscope/init` 一处依旧溢栈(面包屑定位,见 +/// `logging::stage`); +/// * **32 MiB ——不再崩**,故取作默认值。 +/// +/// 32 MiB 是**保留**的虚拟地址、按需提交,8 个 worker 的虚拟占用对物理内存 +/// 几乎没影响;真要再往上,用 `AGENT2API_THREAD_STACK_MB`(4–64)即可, +/// 不必重新编译。 +pub fn worker_stack_bytes() -> usize { + let mb = std::env::var("AGENT2API_THREAD_STACK_MB").ok() + .and_then(|raw| raw.trim().parse::().ok()) + .map(|mb| mb.clamp(4, 64)) + .unwrap_or(32); + mb * 1024 * 1024 +} + +/// 兼容旧调用的常量名(编译期默认值,实际取值见 [`worker_stack_bytes`])。 +pub const WORKER_STACK_BYTES: usize = 32 * 1024 * 1024; /// 惰性全局运行时:只承接「在非 Tokio 上下文里发起的后台任务」, /// 正常路径(handler / 既有任务体内)不会碰到它。 static GLOBAL_RUNTIME: OnceLock = OnceLock::new(); -/// 构造网关共享配置的多线程 Tokio 运行时(工作线程与阻塞池均使用 8 MiB 栈)。 +/// 构造网关共享配置的多线程 Tokio 运行时(工作线程与阻塞池均使用 +/// [`worker_stack_bytes`] 指定的栈,默认 32 MiB)。 /// /// 桌面端、headless 入口与本 crate 的兜底运行时共用同一构造器, /// 避免某一宿主形态遗漏栈配置。 pub fn build_runtime() -> std::io::Result { tokio::runtime::Builder::new_multi_thread() - .thread_stack_size(WORKER_STACK_BYTES) + .thread_stack_size(worker_stack_bytes()) .enable_all() .build() } diff --git a/desktop-tauri/src-tauri/server/src/server/api/accounts.rs b/desktop-tauri/src-tauri/server/src/server/api/accounts.rs index 169042de8..2d39d147c 100644 --- a/desktop-tauri/src-tauri/server/src/server/api/accounts.rs +++ b/desktop-tauri/src-tauri/server/src/server/api/accounts.rs @@ -403,6 +403,9 @@ pub async fn dispatch( query: &str, body: &Bytes, ) -> Response { + // 面包屑:面板首屏就拉这个接口(62 个账号 × 用量 JSON),崩在请求链上时 + // 这条能把它和「启动时的后台维护」区分开。 + crate::server::logging::stage(format!("HTTP {method} {full_path}")); // ① 精确命中 `/api/accounts` if rest.is_none() { match method.as_str() { diff --git a/desktop-tauri/src-tauri/server/src/server/api/retry_api.rs b/desktop-tauri/src-tauri/server/src/server/api/retry_api.rs index 2caed0a15..02ff3ed85 100644 --- a/desktop-tauri/src-tauri/server/src/server/api/retry_api.rs +++ b/desktop-tauri/src-tauri/server/src/server/api/retry_api.rs @@ -26,8 +26,8 @@ use serde_json::{json, Value}; use crate::server::config::{ self, RetryPatch, RetrySettings, KEY_RETRY_ACCOUNT_SWITCH_COUNT, KEY_RETRY_COUNT, KEY_RETRY_INTERVAL_SECONDS, KEY_RETRY_NO_RETRY_CODES, RETRY_CODE_MAX, RETRY_CODE_MIN, - RETRY_MAX_COUNT, RETRY_MAX_INTERVAL_SECONDS, RETRY_MAX_NO_RETRY_CODES, RETRY_MIN_COUNT, - RETRY_MIN_INTERVAL_SECONDS, + RETRY_MAX_COUNT, RETRY_MAX_INTERVAL_SECONDS, RETRY_MAX_NO_RETRY_CODES, RETRY_MAX_SWITCH_COUNT, + RETRY_MIN_COUNT, RETRY_MIN_INTERVAL_SECONDS, }; use crate::server::errors; use crate::server::http::{ok_json, parse_body}; @@ -67,7 +67,7 @@ pub async fn put_retry(State(_state): State, body: Bytes) -> Respon KEY_RETRY_ACCOUNT_SWITCH_COUNT, object.get(KEY_RETRY_ACCOUNT_SWITCH_COUNT), RETRY_MIN_COUNT, - RETRY_MAX_COUNT, + RETRY_MAX_SWITCH_COUNT, &mut patch.account_switch_count, ), ( @@ -96,9 +96,9 @@ pub async fn put_retry(State(_state): State, body: Bytes) -> Respon } } - // ── 第四项:指定错误码直接换号(整数数组)───────────────────── + // ── 第四项:例外错误码(整数数组,命中 = 允许把错误透传给下游)───────────────────── // 与三个数字项同一顺序:先整单校验,非法整体不落盘。允许 null / 缺省 - // (这一项不动);空数组是合法值 = 清空名单(任何错误都照常重试)。 + // (这一项不动);空数组是合法值 = 没有例外(任何错误都换号)。 if let Some(value) = object.get(KEY_RETRY_NO_RETRY_CODES) { if !value.is_null() { match parse_no_retry_codes(value) { @@ -147,7 +147,7 @@ fn retry_json(settings: RetrySettings) -> Value { }) } -/// 「指定错误码直接换号」的校验:整数数组、每项 100–599、最多 50 项。 +/// 「例外错误码」的校验:整数数组、每项 100–599、最多 50 项。 /// /// 与 `parse_bounded_int` 同一口径:只认 JSON 数字(含 `402.0` 这种整值浮点); /// 有一项非法就整单 400(不悄悄剔除),写盘前排序去重,落库形态规整。 diff --git a/desktop-tauri/src-tauri/server/src/server/config/error_policy.rs b/desktop-tauri/src-tauri/server/src/server/config/error_policy.rs index dff87dae0..9696eed6a 100644 --- a/desktop-tauri/src-tauri/server/src/server/config/error_policy.rs +++ b/desktop-tauri/src-tauri/server/src/server/config/error_policy.rs @@ -21,6 +21,7 @@ impl Default for ErrorPolicySnapshot { pub(crate) fn from_raw(raw: &Map) -> Arc { if let Some(value) = raw.get(KEY_ERROR_POLICY) { if let Ok(settings) = serde_json::from_value::(value.clone()) { + let settings = upgrade_rules(settings); if settings.validate().is_ok() { return Arc::new(ErrorPolicySnapshot { settings, configured: true, legacy: false }); } } } @@ -46,12 +47,16 @@ pub(crate) fn from_raw(raw: &Map) -> Arc { if let Some(rule) = settings.rules.iter_mut().find(|rule| rule.kind == ErrorKind::RateLimit) { rule.fallback_seconds = 600; rule.exponential = true; } + // 旧「指定错误码直接换号」名单 → **例外**规则(允许把错误透传给下游)。 + // 语义在 #644 之后反转:默认所有上游错误都换号,名单表达的是「这几个码 + // 不换、直接返回客户端」。所以这里生成的是 `ReturnError` 例外,而不是 + // 原来的 `SwitchAccount`。 for status in retry.no_retry_codes.iter().copied().filter(|status| (400..600).contains(status)) { let kind = legacy_kind(status); - if matches!(kind, ErrorKind::BadRequest | ErrorKind::Content) { continue; } if let Some(mut rule) = settings.rules.iter().find(|rule| rule.kind == kind).cloned() { - rule.id = format!("legacy-{status}"); rule.name = format!("原直接换号设置 {status}"); rule.statuses = vec![status]; - rule.action = ErrorAction::SwitchAccount; + rule.id = format!("legacy-{status}"); rule.name = format!("原错误码名单例外 {status}"); + rule.statuses = vec![status]; rule.action = ErrorAction::ReturnError; + rule.cooldown = CooldownMode::None; if kind == ErrorKind::Unsupported { rule.scope = CooldownScope::Model; } settings.overrides.push(rule); } @@ -60,6 +65,57 @@ pub(crate) fn from_raw(raw: &Map) -> Arc { Arc::new(ErrorPolicySnapshot { settings, configured: false, legacy }) } +/// 把旧版本的存盘规则补到 [`RULES_VERSION`] 的口径。 +/// +/// 为什么必须做:规则表随版本出厂,用户在面板上真正关心的往往只是「要不要 +/// 换号」,冷却那几格常年停留在出厂值。#644 之前出厂值是「请求有误 / 内容被拒 / +/// 其他错误一律不冷却」,于是本地构造期的 400(例如网页工具字符预算超限) +/// 既白烧换号预算、又不会给失败的 账号×模型 留任何限制 —— 下一条请求继续 +/// 挑中它、继续 400。升级二进制却还带着旧存盘,表现就是「代码改了、线上原样」。 +/// +/// 升级只做**加法**,不动用户选的动作与数值: +/// 1. 冷却为空、而当前出厂值要求「固定冷却 / 失败退避」的规则,按出厂值补上 +/// (这就是「限制器」—— 有错就得挡一会儿,而不是任由下一条请求再撞); +/// 2. `未知错误` 的兜底动作若仍是「直接返回下游」,改回换号(旧出厂值就是这么 +/// 写的,而它和「路由组要保证下游不中断」直接冲突)。 +/// +/// 例外规则(`overrides`)是用户自己配的透传名单,任何时候都不动。 +fn upgrade_rules(mut settings: ErrorSettings) -> ErrorSettings { + if settings.rules_version >= RULES_VERSION { return settings; } + let stock = default_rules(); + let mut cooled = 0; + for rule in settings.rules.iter_mut() { + let Some(default) = stock.iter().find(|item| item.kind == rule.kind) else { continue }; + if rule.cooldown == CooldownMode::None + && matches!(default.cooldown, CooldownMode::Fixed | CooldownMode::Protection) + { + rule.cooldown = default.cooldown; + if rule.fallback_seconds == 0 { rule.fallback_seconds = default.fallback_seconds; } + rule.fallback_cap_seconds = rule.fallback_cap_seconds.max(rule.fallback_seconds); + cooled += 1; + } + if rule.kind == ErrorKind::Unknown && rule.action == ErrorAction::ReturnError { + rule.action = ErrorAction::SwitchAccount; + } + } + // 熔断从 v3 起是默认口径(而不是只对「连接或服务异常」生效的那一档): + // 存盘里仍是关闭的,说明当年跑的就是旧口径,跟着升级打开 —— 否则升级了 + // 二进制,失败的账号照样冷却一到期就回到队首。 + let mut breaker_turned_on = false; + if !settings.breaker { + settings.breaker = true; + settings.breaker_failures = settings.breaker_failures.clamp(1, 3); + breaker_turned_on = true; + } + let versioned = settings.rules_version; + settings.rules_version = RULES_VERSION; + crate::server::logging::console_line("[Config]", &format!( + "错误处理规则已从旧版本(v{versioned})升级到 v{RULES_VERSION}:{cooled} 条规则补上冷却,未知错误恢复换号{}", + if breaker_turned_on { ",熔断打开(连续失败阈值 3)" } else { "" } + )); + settings +} + pub fn snapshot() -> Arc { super::CONFIG.read().ok().and_then(|guard| guard.as_ref().map(|config| config.error_policy.clone())).unwrap_or_default() } @@ -69,8 +125,12 @@ pub fn revision(snapshot: &ErrorPolicySnapshot) -> String { "legacy": snapshot.legacy }).to_string().as_bytes())) } -pub fn save(settings: ErrorSettings, expected: &str) -> Result, crate::server::errors::GatewayError> { +pub fn save(mut settings: ErrorSettings, expected: &str) -> Result, crate::server::errors::GatewayError> { use crate::server::errors::GatewayError; + // 前端提交的规则就是「当前版本的规则」:老前端不带 `rulesVersion`,被 + // serde 默认成 0 的话,保存一次就会被下一次加载当成旧配置又升级一遍, + // 用户刚改的动作会被默认值覆盖。所以保存时统一盖上当前版本号。 + settings.rules_version = RULES_VERSION; settings.validate().map_err(GatewayError::bad_request)?; super::try_update_raw_fields(|raw| { if revision(&from_raw(raw)) != expected { return Err(GatewayError::with_status(409, "错误处理设置已在其他窗口修改,请重新读取后保存")); } @@ -91,7 +151,7 @@ pub(crate) fn write_settings(raw: &mut Map, settings: &ErrorSetti for (key, value) in [(super::KEY_ROUTING_FAILOVER_BACKOFF, settings.backoff), (super::KEY_ROUTING_SINK, settings.sink), (super::KEY_ROUTING_BREAKER_ENABLED, settings.breaker)] { raw.insert(key.into(), value.into()); } raw.insert(super::KEY_RETRY_NO_RETRY_CODES.into(), settings.overrides.iter() - .filter(|rule| rule.id.starts_with("legacy-") && rule.enabled && rule.action == ErrorAction::SwitchAccount) + .filter(|rule| rule.id.starts_with("legacy-") && rule.enabled && rule.action == ErrorAction::ReturnError) .flat_map(|rule| rule.statuses.iter().copied()).map(Value::from).collect::>().into()); Ok(()) } @@ -111,10 +171,10 @@ pub(crate) fn sync_legacy(raw: &mut Map, retry_codes_changed: boo settings.overrides.retain(|rule| !rule.id.starts_with("legacy-")); for status in retry.no_retry_codes.iter().copied().filter(|status| (400..600).contains(status)) { let kind = legacy_kind(status); - if matches!(kind, ErrorKind::BadRequest | ErrorKind::Content) { continue; } if let Some(mut rule) = settings.rules.iter().find(|rule| rule.kind == kind).cloned() { - rule.id = format!("legacy-{status}"); rule.name = format!("原直接换号设置 {status}"); - rule.statuses = vec![status]; rule.action = ErrorAction::SwitchAccount; + rule.id = format!("legacy-{status}"); rule.name = format!("原错误码名单例外 {status}"); + rule.statuses = vec![status]; rule.action = ErrorAction::ReturnError; + rule.cooldown = CooldownMode::None; if kind == ErrorKind::Unsupported { rule.scope = CooldownScope::Model; } settings.overrides.insert(0, rule); } @@ -130,3 +190,44 @@ fn legacy_kind(status: u16) -> ErrorKind { 408 | 500 | 502 | 503 | 504 => ErrorKind::Transient, _ => ErrorKind::Unknown, } } + +#[cfg(test)] +mod tests { + use super::*; + use serde_json::Map; + + /// 旧存盘里「所有规则都不冷却」时,升级要补上限制器,而不是放任旧口径。 + #[test] + fn stale_rules_get_cooldowns_on_upgrade() { + let mut settings = ErrorSettings::default(); + settings.rules_version = 0; + for rule in settings.rules.iter_mut() { rule.cooldown = CooldownMode::None; } + let mut raw = Map::new(); + raw.insert(KEY_ERROR_POLICY.into(), serde_json::to_value(&settings).expect("serialize")); + let snapshot = from_raw(&raw); + assert_eq!(snapshot.settings.rules_version, RULES_VERSION); + for rule in &snapshot.settings.rules { + if matches!(rule.kind, ErrorKind::BadRequest | ErrorKind::Content | ErrorKind::Unknown) { + assert_ne!(rule.cooldown, CooldownMode::None, "{} 升级后必须有冷却", rule.kind.id()); + } + } + assert!(snapshot.settings.validate().is_ok(), "升级后的设置必须自身合法"); + } + + /// 用户配的例外(透传名单)在升级时原样保留。 + #[test] + fn user_overrides_survive_upgrade() { + let mut settings = ErrorSettings::default(); + settings.rules_version = 0; + let mut rule = default_rules().into_iter().find(|rule| rule.kind == ErrorKind::BadRequest).expect("bad_request 规则"); + rule.id = "legacy-400".into(); rule.statuses = vec![400]; + rule.action = ErrorAction::ReturnError; rule.cooldown = CooldownMode::None; + settings.overrides.push(rule); + let mut raw = Map::new(); + raw.insert(KEY_ERROR_POLICY.into(), serde_json::to_value(&settings).expect("serialize")); + let snapshot = from_raw(&raw); + assert_eq!(snapshot.settings.overrides.len(), 1, "例外不能被升级逻辑丢掉"); + assert_eq!(snapshot.settings.overrides[0].action, ErrorAction::ReturnError); + assert_eq!(snapshot.settings.overrides[0].id, "legacy-400"); + } +} diff --git a/desktop-tauri/src-tauri/server/src/server/config/error_policy_types.rs b/desktop-tauri/src-tauri/server/src/server/config/error_policy_types.rs index b79cbedd3..0e20d3b5b 100644 --- a/desktop-tauri/src-tauri/server/src/server/config/error_policy_types.rs +++ b/desktop-tauri/src-tauri/server/src/server/config/error_policy_types.rs @@ -54,9 +54,36 @@ pub struct ErrorRule { fn all_providers() -> String { "*".into() } fn enabled() -> bool { true } +/// 换账号上限的上界:与转发层 `MAX_ROUTE_ATTEMPTS` 对齐。 +/// +/// 路由的意义是「试到有候选能答上来为止」,所以默认值取一个足够大的数 —— +/// 队列里有几个可用账号就试几个。上限放到 100(而不是 32):账号多的部署 +/// 一次排队就能排到几十个候选,「配了 100 却只换 32 次」等于又给队列截了尾。 +pub const MAX_SWITCHES: u64 = 100; + +/// 默认规则集的版本号。 +/// +/// 规则是**出厂默认**而不是用户手写的清单:升级到本版之后默认动作统一改成 +/// 「换号 / 跳过这一家」,并给请求有误类错误补上短冷却(避免同一个已知坏掉的 +/// 账号×模型被下一条请求反复挑中)。旧版本存下来的 `routingErrorPolicy` +/// 里那套 `return_error + 不冷却` 的组合必须跟着升级,否则用户升级了二进制 +/// 却还在跑旧口径 —— 见 `config::error_policy::from_raw` 的升级分支。 +/// +/// v3:登录失效(401)也带账号级短冷却。续期没救回来的账号如果既不冷却、 +/// 也不退出轮转,下一条请求还会轮到它再吃一次 401 —— 日志上就是每隔几秒 +/// 一条 401,队列里明明有别的家能答,却一直排在一个已经失效的账号后面。 +pub const RULES_VERSION: u64 = 3; + #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] #[serde(default, rename_all = "camelCase", deny_unknown_fields)] pub struct ErrorSettings { + /// 默认规则集的版本;0 = 本字段出现之前的旧配置。 + /// + /// 这里必须写字段级 `#[serde(default)]`:结构体上已有 `#[serde(default)]`, + /// 缺字段时会回落到 `ErrorSettings::default()` 的值(= 最新版本),那样旧 + /// 存盘就会被当成「已经是最新口径」而跳过升级。字段级默认取 0 才对。 + #[serde(default)] + pub rules_version: u64, pub resends: u64, pub switches: u64, pub interval_seconds: u64, @@ -78,9 +105,12 @@ pub struct ErrorSettings { impl Default for ErrorSettings { fn default() -> Self { Self { - resends: 3, switches: 5, interval_seconds: 5, wait_budget_seconds: 30, cooldown_floor_seconds: 30, + rules_version: RULES_VERSION, + resends: 0, switches: MAX_SWITCHES, interval_seconds: 5, wait_budget_seconds: 30, cooldown_floor_seconds: 30, backoff: true, backoff_seconds: 30, backoff_cap_seconds: 300, sink: true, sink_seconds: 1800, - breaker: false, breaker_failures: 5, breaker_seconds: 60, breaker_successes: 2, + // 熔断默认打开:失败的账号连续失败到阈值后先退出轮转,让队列里 + // 其他家先接活 —— 冷却只是「过一会儿再试」,熔断才是「先别用它」。 + breaker: true, breaker_failures: 3, breaker_seconds: 120, breaker_successes: 2, rules: default_rules(), overrides: Vec::new(), } } @@ -94,23 +124,42 @@ pub fn default_rules() -> Vec { id: kind.id().into(), name: name.into(), kind, statuses: statuses.to_vec(), code: String::new(), provider: "*".into(), model: String::new(), enabled: true, action, cooldown, fallback_seconds, exponential, fallback_cap_seconds: 1800, scope, }; + // ── 默认动作统一为「换下一个候选」───────────────────────── + // 路由的职责是让下游不中断:上游任何一次失败都说明「这个账号 × 这个模型 + // 这一次没答上来」,换一个候选(同家另一个账号、另一家、路由组里的另一个 + // 成员模型)仍可能成功。所以除登录失效(先续期再换)与能力不支持(换家) + // 之外,全部直接顺延,**不做同一账号的原地重发** —— 那只会让客户端干等, + // 并且把「上游已经明确拒绝」当成「再试一次也许就好了」。 + // + // 冷却只给真正属于账号/额度状态的类型:限流、额度、余额、连接或服务异常 + // (退避 + 熔断计数)、登录失效(账号级)。请求本身有误(400/413/422)、 + // 内容被拒(内容策略)与能力不支持也**留一段短冷却**:不是为了惩罚账号, + // 而是为了让「刚在同一个 账号×模型 上失败过的组合」在接下来的几十秒里别 + // 再被同一条坏请求抢着试一遍 —— 这就是用户要的「限制器」。 + // + // 登录失效(401)原本没有冷却:续期失败后账号既不冷却、也不会被移出队列, + // 于是**下一条请求**仍然轮到它、再吃一次 401、再续期一次 —— 日志里的 + // 「每隔几秒一条 CodeArts 401」就是这么来的。现在给它一段账号级短冷却: + // 续期没救回来的账号先退出轮转 60 秒,让队列里别的候选先去答。 + // 要「允许直接把错误返回下游」的码,走「提供商例外」(`overrides`)配置, + // 见 `config::error_policy` 对旧「指定错误码」名单的映射。 vec![ rule(RateLimit, "请求限流", &[429], SwitchAccount, Upstream, 60, false, CooldownScope::Auto), rule(Quota, "额度耗尽", &[429], SwitchAccount, Upstream, 600, true, CooldownScope::Auto), - rule(Auth, "登录失效", &[401], RefreshThenSwitch, None, 60, false, CooldownScope::Account), + rule(Auth, "登录失效", &[401], RefreshThenSwitch, Fixed, 60, false, CooldownScope::Account), rule(Balance, "余额不足", &[402], SwitchAccount, Upstream, 600, false, CooldownScope::Account), - rule(Transient, "连接或服务异常", &[408, 500, 502, 503, 504], RetryThenSwitch, Protection, 60, false, CooldownScope::Auto), - rule(Unsupported, "能力不支持", &[501], SwitchProvider, None, 60, false, CooldownScope::Auto), - rule(BadRequest, "请求有误", &[400, 413, 422], ReturnError, None, 60, false, CooldownScope::Model), - rule(Content, "内容被拒绝", &[], ReturnError, None, 60, false, CooldownScope::Model), - rule(Unknown, "其他错误", &[], ReturnError, None, 60, false, CooldownScope::Auto), + rule(Transient, "连接或服务异常", &[408, 500, 502, 503, 504], SwitchAccount, Protection, 60, false, CooldownScope::Auto), + rule(Unsupported, "能力不支持", &[501], SwitchProvider, Fixed, 60, false, CooldownScope::Model), + rule(BadRequest, "请求有误", &[400, 413, 422], SwitchAccount, Fixed, 60, false, CooldownScope::Model), + rule(Content, "内容被拒绝", &[], SwitchAccount, Fixed, 60, false, CooldownScope::Model), + rule(Unknown, "其他错误", &[], SwitchAccount, Protection, 60, false, CooldownScope::Auto), ] } impl ErrorSettings { pub fn validate(&self) -> Result<(), String> { let bounds = [ - (self.resends, 0, 10, "原账号重发次数"), (self.switches, 0, 10, "换账号上限"), + (self.resends, 0, 10, "原账号重发次数"), (self.switches, 0, MAX_SWITCHES, "换账号上限"), (self.interval_seconds, 0, 300, "重发间隔"), (self.wait_budget_seconds, 0, 300, "累计等待上限"), (self.cooldown_floor_seconds, 1, 60, "最短冷却"), (self.backoff_seconds, 1, 3600, "首次失败休息"), (self.backoff_cap_seconds, self.backoff_seconds, 3600, "最长失败休息"), (self.sink_seconds, 30, 3600, "降低优先级时长"), @@ -121,6 +170,7 @@ impl ErrorSettings { if !(min..=max).contains(&value) { return Err(format!("{name}必须是 {min}–{max} 的整数")); } } if self.rules.len() != 9 || self.overrides.len() > 100 { return Err("全局错误规则必须完整,提供商例外最多 100 条".into()); } + if self.rules_version > RULES_VERSION { return Err("这份设置来自更新的版本,请升级后再保存".into()); } let mut ids = std::collections::HashSet::new(); let mut kinds = std::collections::HashSet::new(); for (rule, global) in self.rules.iter().map(|rule| (rule, true)).chain(self.overrides.iter().map(|rule| (rule, false))) { @@ -136,8 +186,12 @@ impl ErrorSettings { if rule.kind != ErrorKind::Auth && rule.action == ErrorAction::RefreshThenSwitch { return Err("仅登录失效规则可以使用凭证续期".into()); } - if matches!(rule.kind, ErrorKind::BadRequest | ErrorKind::Content) && (rule.action != ErrorAction::ReturnError || rule.cooldown != CooldownMode::None) { - return Err("已识别的请求错误和内容拒绝不能设置为重复发送、换号或账号冷却".into()); + // 请求有误 / 内容被拒:既可以换号(默认)、跳过这一家,也可以透传下游; + // 冷却只能是「固定时长 / 失败退避 / 不冷却」—— 上游这类响应通常不带 + // `resetAt`,按上游时间冷却等于把账号无限期挂住。 + if matches!(rule.kind, ErrorKind::BadRequest | ErrorKind::Content) && (rule.cooldown == CooldownMode::Upstream + || !matches!(rule.action, ErrorAction::ReturnError | ErrorAction::SwitchAccount | ErrorAction::SwitchProvider)) { + return Err("已识别的请求错误和内容拒绝只能选择换账号、跳过该提供商或返回下游,且不能按上游时间冷却".into()); } if rule.kind == ErrorKind::Unknown && !rule.enabled { return Err("其他错误的兜底规则不能关闭".into()); } } @@ -153,3 +207,71 @@ impl ErrorSettings { .unwrap_or(&self.rules[0]) } } + +#[cfg(test)] +mod tests { + use super::*; + + /// 默认口径:除登录失效(先续期)与能力不支持(换家)之外,全部换号; + /// 一次原地重发都不做,换号上限覆盖整条候选队列。 + #[test] + fn defaults_fail_over_on_every_upstream_error() { + let settings = ErrorSettings::default(); + assert_eq!(settings.resends, 0, "默认不做同一账号原地重发"); + assert_eq!(settings.switches, MAX_SWITCHES, "默认换号上限要能走完候选队列"); + assert!(settings.validate().is_ok(), "默认设置必须自身合法"); + for rule in &settings.rules { + match rule.kind { + ErrorKind::Auth => assert_eq!(rule.action, ErrorAction::RefreshThenSwitch), + ErrorKind::Unsupported => assert_eq!(rule.action, ErrorAction::SwitchProvider), + _ => assert_eq!(rule.action, ErrorAction::SwitchAccount, "{} 默认应换号", rule.kind.id()), + } + } + } + + /// 登录失效也要留冷却:续期没救回来的账号必须先退出轮转,否则下一条请求 + /// 还会轮到它、再吃一次 401(日志上就是每隔几秒一条 401)。 + #[test] + fn auth_rule_cools_the_account_after_401() { + let settings = ErrorSettings::default(); + let rule = settings.rules.iter().find(|rule| rule.kind == ErrorKind::Auth).expect("auth rule"); + assert_eq!(rule.action, ErrorAction::RefreshThenSwitch, "401 仍然先续期"); + assert_ne!(rule.cooldown, CooldownMode::None, "401 续期失败后要冷却账号"); + assert_eq!(rule.scope, CooldownScope::Account, "401 是账号级的失效"); + } + + /// 熔断默认打开、阈值要短:失败的账号先退出轮转,而不是冷却一到期就回到队首。 + #[test] + fn breaker_is_on_by_default() { + let settings = ErrorSettings::default(); + assert!(settings.breaker, "失败的账号要能被熔断摘出轮转"); + assert!(settings.breaker_failures <= 3, "阈值要短,才拦得住反复撞墙的账号"); + assert!(settings.validate().is_ok(), "默认设置必须自身合法"); + } + + /// 请求有误 / 内容被拒默认也换号(并留短冷却);显式配成 ReturnError 依然合法。 + #[test] + fn bad_request_and_content_may_switch_or_passthrough() { + let settings = ErrorSettings::default(); + assert!(settings.validate().is_ok()); + let mut passthrough = ErrorSettings::default(); + for rule in &mut passthrough.rules { + if matches!(rule.kind, ErrorKind::BadRequest | ErrorKind::Content) { + rule.action = ErrorAction::ReturnError; + rule.cooldown = CooldownMode::None; + } + } + assert!(passthrough.validate().is_ok()); + } + + /// 换号上限的新上界必须容得下默认值。 + #[test] + fn switch_bounds_cover_default() { + assert!(MAX_SWITCHES >= 10); + let mut settings = ErrorSettings::default(); + settings.switches = MAX_SWITCHES; + assert!(settings.validate().is_ok()); + settings.switches = MAX_SWITCHES + 1; + assert!(settings.validate().is_err()); + } +} diff --git a/desktop-tauri/src-tauri/server/src/server/config/parse.rs b/desktop-tauri/src-tauri/server/src/server/config/parse.rs index d74139036..6db783f08 100644 --- a/desktop-tauri/src-tauri/server/src/server/config/parse.rs +++ b/desktop-tauri/src-tauri/server/src/server/config/parse.rs @@ -329,7 +329,7 @@ pub(super) fn retry_from(map: &Map) -> RetrySettings { KEY_RETRY_ACCOUNT_SWITCH_COUNT, defaults.account_switch_count, RETRY_MIN_COUNT, - RETRY_MAX_COUNT, + RETRY_MAX_SWITCH_COUNT, ), interval_seconds: bounded_int_field( map, @@ -342,14 +342,13 @@ pub(super) fn retry_from(map: &Map) -> RetrySettings { } } -/// 「指定错误码直接换号」名单的解析。 +/// **例外**错误码名单的解析(命中 = 允许把错误透传给下游、不换号)。 /// /// ── 各形态的落点 ──────────────────────────────────────────── -/// - 键缺失 / 不是数组 → **默认名单**([402]):配置从没写过这一项是常态, -/// 默认值就该在这时出现;整体写坏(手改成了字符串)与「没配过」无法区分, -/// 按同一口径处理(回落默认,见模块头)。 -/// - 空数组 → **空名单**:这是用户的明确选择(任何错误都照常重试), -/// 必须与「没配过」区分开。 +/// - 键缺失 / 不是数组 → **空名单**:默认就是「任何上游错误都换号」, +/// 没有例外。整体写坏(手改成了字符串)与「没配过」无法区分,按同一 +/// 口径处理(回落默认,见模块头)。 +/// - 空数组 → **空名单**:与默认一致,语义是「没有例外」。 /// - 数组里的垃圾项(非整数 / 越出 100–599)→ **丢弃该项**:接口写入侧 /// 已整单校验(400),能到这里的坏项只来自手改库,跳过比整单回落默认 /// 更接近手改者的本意。排序去重:判定只问 contains,顺序无意义, diff --git a/desktop-tauri/src-tauri/server/src/server/config/types.rs b/desktop-tauri/src-tauri/server/src/server/config/types.rs index 98638daa9..76e80f47b 100644 --- a/desktop-tauri/src-tauri/server/src/server/config/types.rs +++ b/desktop-tauri/src-tauri/server/src/server/config/types.rs @@ -643,27 +643,30 @@ pub const KEY_RETRY_ACCOUNT_SWITCH_COUNT: &str = "retryCrossProviderCount"; /// 两次重试之间的等待秒数 pub const KEY_RETRY_INTERVAL_SECONDS: &str = "retryIntervalSeconds"; -/// 同一账号的原地重发次数默认值:失败后再试 3 次(连同首发共 4 次发送) -pub const DEFAULT_RETRY_COUNT: i64 = 3; -/// 换账号的次数默认值:失败后最多换 5 个账号。 -/// -/// 比原地重发那档更宽是刻意的:换号的成本主要在「等到下一个可用账号」, -/// 而一个账号失败往往说明它这份额度确实不通,多换几个比快速失败更符合预期。 -pub const DEFAULT_RETRY_SWITCH_COUNT: i64 = 5; +/// 同一账号的原地重发次数默认值:0 —— 上游明确报错后不再原地重发。 +/// +/// 原地重发的成本是「客户端干等一个间隔」,收益只是「上游也许抖了一下」。 +/// 有别的候选时,换一个账号/模型的成功率高得多,所以默认直接顺延;需要 +/// 原地重发的人可以在设置里调大。 +pub const DEFAULT_RETRY_COUNT: i64 = 0; +/// 换账号的次数默认值:32 —— 覆盖绝大多数部署的候选队列;上限另见 +/// [`RETRY_MAX_SWITCH_COUNT`](100),账号多的人可以自己往上调。 +pub const DEFAULT_RETRY_SWITCH_COUNT: i64 = 32; /// 重试间隔默认值:5 秒 pub const DEFAULT_RETRY_INTERVAL_SECONDS: i64 = 5; -/// 「指定错误码直接换号」的配置键(值是 HTTP 状态码数组,如 `[402, 429]`)。 +/// **例外**错误码名单的配置键(值是 HTTP 状态码数组,如 `[400]`)。 +/// +/// ── 语义在 #644 之后反转 ──────────────────────────────── +/// 现在默认是「任何上游错误都换号」,名单表达的是**例外**:命中的状态码 +/// **允许直接返回给下游、不换号**(例如调用方希望自己处理 400 的请求校验错误)。 /// -/// 键名里的 `NoRetry` 是历史措辞(最早的语义是「命中即报错」),行为后来 -/// 改成了「不在同一账号重发、直接换下一个账号」—— 键名是配置契约,改名 -/// 会让老配置读不到,保留至今。命中名单的上游失败跳过本账号:原地重发与 -/// 同账号补救(内容拦截换提示词 / 401 刷新)都不做,按队列换下一个账号 -/// 继续试,换满仍失败才把错误给客户端。 +/// 键名里的 `NoRetry` 是历史措辞(最早的语义是「命中即报错」,后来一度改成 +/// 「命中就直换」),键名是配置契约,改名会让老配置读不到,所以保留至今 —— +/// 语义以本节为准:**命中 = 允许把错误透传给下游(因此不再换号)**。 pub const KEY_RETRY_NO_RETRY_CODES: &str = "noRetryStatusCodes"; -/// 默认名单:402(WorkBuddy 积分不足)。余额问题重发结论不变, -/// 客户端拿到 402 才能如实体感「这个账号没钱了」。 -pub const DEFAULT_NO_RETRY_CODES: &[u16] = &[402]; +/// 默认名单:空 —— 任何上游错误都换号,不把错误透传给下游。 +pub const DEFAULT_NO_RETRY_CODES: &[u16] = &[]; /// 名单里状态码的合法范围:HTTP 状态码本身就定义在 100–599 pub const RETRY_CODE_MIN: u16 = 100; pub const RETRY_CODE_MAX: u16 = 599; @@ -678,6 +681,12 @@ pub const RETRY_MAX_NO_RETRY_CODES: usize = 50; /// 该档(不重发 / 不换号),间隔 0 = 立即重发。 pub const RETRY_MIN_COUNT: i64 = 0; pub const RETRY_MAX_COUNT: i64 = 10; +/// 「换账号次数」的上界:与转发层 `MAX_ROUTE_ATTEMPTS`(100)对齐。 +/// +/// 换账号不是「重发」:一份请求最多试几个候选,本身受循环上限约束,所以 +/// 这里放到 100,让账号多的部署能把整条队列试完,而不是被一个 10 次的上界 +/// 提前收尾。 +pub const RETRY_MAX_SWITCH_COUNT: i64 = 100; pub const RETRY_MIN_INTERVAL_SECONDS: i64 = 0; pub const RETRY_MAX_INTERVAL_SECONDS: i64 = 300; @@ -700,11 +709,12 @@ pub struct RetrySettings { pub account_switch_count: i64, /// 两次重试之间的间隔(秒) pub interval_seconds: i64, - /// **指定错误码直接换号**名单([`KEY_RETRY_NO_RETRY_CODES`])。 + /// **例外**错误码名单([`KEY_RETRY_NO_RETRY_CODES`]):命中的上游状态码允许 + /// 直接返回给下游、不再换号。 /// - /// 为什么是 `Arc<[u16]>` 而不是 `Vec`:快照被逐失败请求取用, - /// `Arc` 让克隆只付一次指针自增;判定(`no_retry`)读的是共享切片, - /// 不需要任何锁。 + /// 默认空 = 任何上游错误都换号。为什么是 `Arc<[u16]>` 而不是 `Vec`: + /// 快照被逐失败请求取用,`Arc` 让克隆只付一次指针自增;判定(`no_retry`) + /// 读的是共享切片,不需要任何锁。 pub no_retry_codes: Arc<[u16]>, } @@ -727,7 +737,7 @@ impl RetrySettings { self.account_switch_count.max(0) as usize } - /// 这个上游状态码是否命中「直接换号」名单。 + /// 这个上游状态码是否在**例外**名单里(命中 = 允许直接把错误返回下游)。 pub fn no_retry(&self, status: u16) -> bool { self.no_retry_codes.contains(&status) } diff --git a/desktop-tauri/src-tauri/server/src/server/core/credential_maintenance.rs b/desktop-tauri/src-tauri/server/src/server/core/credential_maintenance.rs index 598572231..d9d10d470 100644 --- a/desktop-tauri/src-tauri/server/src/server/core/credential_maintenance.rs +++ b/desktop-tauri/src-tauri/server/src/server/core/credential_maintenance.rs @@ -246,6 +246,8 @@ pub async fn refresh_accounts(store: &AccountStore, selected: Option<&[String]>, // 不会中断循环(见模块头的失败隔离)。 let started = std::time::Instant::now(); let credential_stamp = store.credential_stamp(&id); + // 面包屑:万一在这一步爆栈(wasm 插件调用链),最后一行就是它 + logging::stage(format!("凭证刷新 {provider}/{id}")); let result = refresh_checked(store, adapter.as_ref(), &id).await.map(|_| ()); let mut row = match &result { Ok(_) => json!({ diff --git a/desktop-tauri/src-tauri/server/src/server/core/maintenance/mod.rs b/desktop-tauri/src-tauri/server/src/server/core/maintenance/mod.rs index 7d911b769..ec23b774a 100644 --- a/desktop-tauri/src-tauri/server/src/server/core/maintenance/mod.rs +++ b/desktop-tauri/src-tauri/server/src/server/core/maintenance/mod.rs @@ -268,12 +268,15 @@ async fn complete( recorder: storage::Recorder, ) -> Result { let manual = request.source == "manual"; + logging::stage(format!("维护开始 task={}", request.task_id)); let snapshots = types::accounts(store); let raw = if request.task_id == CREDENTIAL { if request.forced_account_ids.is_empty() { + logging::stage("维护分支:凭证维护(自动)"); credential_maintenance::refresh_selected_accounts(store, request.account_ids.as_deref()) .await } else { + logging::stage("维护分支:凭证维护(指定账号)"); credential_maintenance::refresh_accounts( store, request.account_ids.as_deref(), @@ -282,6 +285,7 @@ async fn complete( .await } } else if manual { + logging::stage("维护分支:模型/凭证刷新(手动)"); providers::adapter::refresh_implemented_forced( store, &request.accounts, @@ -289,8 +293,10 @@ async fn complete( ) .await } else { + logging::stage("维护分支:模型/凭证刷新(自动)"); providers::adapter::refresh_implemented(store).await }; + logging::stage("维护分支完成,开始整理逐账号结果"); let mut items = raw .iter() .enumerate() diff --git a/desktop-tauri/src-tauri/server/src/server/core/plugin_host/wasm/runtime.rs b/desktop-tauri/src-tauri/server/src/server/core/plugin_host/wasm/runtime.rs index e245afae3..c928b8a17 100644 --- a/desktop-tauri/src-tauri/server/src/server/core/plugin_host/wasm/runtime.rs +++ b/desktop-tauri/src-tauri/server/src/server/core/plugin_host/wasm/runtime.rs @@ -250,6 +250,13 @@ impl Runtime { .map_or(tokio::time::Instant::now() + timeout, |deadline| deadline.min(tokio::time::Instant::now() + timeout)); let query_reserved = !interactive && super::query_queue::reserved(&self.shared, &account, method)?; let diagnostics = super::diagnostics::Invocation::new(&self.shared.options.provider, method, &self.module_digest); + // 面包屑:wasm 调用是栈溢出高危区(debug 构建下加载/执行插件曾把默认 + // 2 MiB 栈打穿,见 `server::lib::worker_stack_bytes`)。万一崩在这里, + // 控制台最后一行就是「哪个 provider 的哪个方法」。 + crate::server::logging::stage(format!( + "wasm {}/{} account={} bytes={}", + self.shared.options.provider, method, account, input_bytes, + )); let work = async { let wait_started = tokio::time::Instant::now(); let queue_deadline = (tokio::time::Instant::now() + Duration::from_secs(capacity::limits().queue_wait_seconds)).min(call_deadline); diff --git a/desktop-tauri/src-tauri/server/src/server/core/routing.rs b/desktop-tauri/src-tauri/server/src/server/core/routing.rs index 562e8d39c..2190c67b6 100644 --- a/desktop-tauri/src-tauri/server/src/server/core/routing.rs +++ b/desktop-tauri/src-tauri/server/src/server/core/routing.rs @@ -471,6 +471,11 @@ pub struct PlanEntry { pub provider: String, /// 状态码:`usable` / `tried` / `disabled` / `cooldown` / `concurrency` / /// `limiter` / `no-credentials` + /// + /// `concurrency` 会出现在**两份清单里**:仍然算「不可用」的只有真正的死状态 + /// (禁用 / 冷却 / 余额不足 / 无凭证 / 本轮已试),而「并发已满」只是「现在 + /// 没空」—— 它被收在 `ordered` 的**队尾**排队等槽位(见 `plan_route` 里那段 + /// 说明),所以同一个状态码在 `ordered` 里出现时表示「排队中」。 pub state: &'static str, /// 一句「为什么排这 / 为什么跳过」(队列面板与请求详情直接展示) pub reason: String, @@ -478,7 +483,7 @@ pub struct PlanEntry { pub reset_at: i64, } -/// 一份选路计划:可用候选(排好序)+ 被跳过的候选(各带原因)。 +/// 一份选路计划:可用候选(排好序,末尾接着「忙、排队等槽位」的那几个)+ 被跳过的候选(各带原因)。 pub struct RoutePlan { pub ordered: Vec, pub blocked: Vec, @@ -632,6 +637,8 @@ pub fn plan_route( ) -> RoutePlan { let mut ordered: Vec = Vec::new(); let mut blocked: Vec = Vec::new(); + // 「忙」单独一队:并发满不等于不可用(见收集循环里那处说明)。 + let mut queued: Vec = Vec::new(); for account in accounts { let Some(id) = account_id(account) else { continue }; let id = id.to_string(); @@ -674,13 +681,21 @@ pub fn plan_route( continue; } if at_concurrency_limit(account, &id, counts) { - blocked.push(entry( - "concurrency", - format!( - "并发已满({}/上限),等一个在途回落再参与", - counts.get(&id).copied().unwrap_or(0) - ), - )); + // ── 忙 ≠ 不可用(2026-11-21 修正)─────────────────────────── + // 改造前这里与「禁用 / 冷却 / 余额不足」同一条路:直接进 `blocked`。 + // 后果是「该家三个账号同时有在途请求」时整家从候选里消失,请求于是 + // 落到唯一「看起来空闲」的另一家 —— 而那一家的失败往往是确定性的 + // (没套餐 / 没余额 / 没权限),客户端最后拿到的就是一条 429。实测 + // 一次 `pro` 组请求:43 个账号里 55 个候选被拦,队里只剩 1 个没套餐 + // 的账号,撞 429 后连「顺延到下一家」都做不了(`pick_next_account` + // 走的是同一份 `plan_route`,忙账号在里面也已经被剔掉)。 + // + // 正确定性顺序是「能立刻发 > 忙,等几秒就可用 > 永远不行(禁用 / + // 冷却 / 没余额)」。所以忙账号**不进 `blocked`**,收进 `queued`, + // 排到所有立刻能发的账号之后;发送前的并发预占失败时由 + // `account_admission::select` 原地等槽位(有 `queue_wait_seconds` + // 上限,超时给可重试的 503),而不是把它们当死人跳过。 + queued.push(account.clone()); continue; } if super::plugin_host::wasm::catalog::route_allowed(account, &keys.for_account(account)) == Some(false) { @@ -830,8 +845,38 @@ pub fn plan_route( }) .collect(); + // ── 排队候选接在可用候选之后 ──────────────────────────────────── + // 顺序即优先级:立刻能发的先发,都不行(或发失败要顺延)时再轮到「忙」的那几个, + // 由并发预占处等槽位。它们排在「禁用 / 冷却 / 余额不足」之前 —— 后三类叫 + // 「永远不行」,忙只是「现在没空」,两者不该被同等丢弃。 + // + // 不再按策略轮转:忙账号的先后只由优先级决定。轮转的目的是均摊负载,而这几个 + // 账号此刻本来就被占满,轮到谁都得先等槽位。 + queued.sort_by(compare_by_priority); + let queued_entries: Vec = queued + .into_iter() + .map(|account| { + let id = account_id(&account).unwrap_or("").to_string(); + let busy = counts.get(&id).copied().unwrap_or(0); + PlanEntry { + name: account_name(&account, &id), + provider: provider_of(&account).to_string(), + account, + id, + // 状态沿用 `concurrency`(界面已把它翻成「并发已满」并标成 warning), + // 它们的**位置**和原因句已经在说「排队等槽位」这件事,再新增一个状态 + // 只会让面板、请求详情、状态文案三处各补一遍词条。 + state: "concurrency", + reason: format!( + "并发已满({busy} 个在途已达上限),排队等一个槽位空出来 —— 前面的候选都发不出去时它接着上" + ), + reset_at: 0, + } + }) + .collect(); + RoutePlan { - ordered: ordered_entries, + ordered: ordered_entries.into_iter().chain(queued_entries).collect(), blocked, sticky_hit, } @@ -933,6 +978,39 @@ mod tests { ); } + /// 忙 ≠ 不可用:并发已满的账号排在可用账号之后,而不是进 `blocked`。 + /// + /// 证据(2026-11-21):`pro` 组一条请求 56 个候选里 55 个被跳过,队里只剩一个 + /// 没套餐的账号,撞 429 之后连「顺延到下一家」都做不了 —— 因为顺延走的 + /// `pick_next_account` 用的是同一份 `plan_route`,忙账号在里面也已经被剔掉。 + /// 那几个账号其实只是**都有在途请求**(上限 1、在途 1),等几秒就空出来了。 + #[test] + fn a_busy_account_queues_behind_usable_ones_instead_of_being_dropped() { + let empty_numbers: HashMap = HashMap::new(); + let empty_ids: std::collections::HashSet = std::collections::HashSet::new(); + let keys = CooldownKeys::new("test-model"); + let busy = json!({ "id": "a1", "provider": "A", "priority": 100, "maxConcurrent": 1 }); + let accounts = vec![busy, account("b1", "B", 120)]; + // a1 有一个在途请求、上限 1 ⇒ 忙;b1 没设上限 ⇒ 立刻能发 + let counts: HashMap = HashMap::from([("a1".to_string(), 1usize)]); + let meta = PlanMeta { + strategy: RouteStrategy::Order, + sunk: &empty_numbers, + resting: &empty_numbers, + open: &empty_ids, + limiter_blocked: &empty_ids, + cursor: None, + provider_cursors: None, + sticky_account: None, + }; + let plan = plan_route(&accounts, &keys, &counts, &[], 1_700_000_000_000, &meta); + let order: Vec<&str> = plan.ordered.iter().map(|entry| entry.id.as_str()).collect(); + assert_eq!(order, vec!["b1", "a1"], "立刻能发的在前,忙的接在后面排队"); + assert_eq!(plan.ordered[1].state, "concurrency"); + assert!(plan.ordered[1].reason.contains("排队等一个槽位"), "{}", plan.ordered[1].reason); + assert!(plan.blocked.is_empty(), "忙账号不该再被算成「被跳过」"); + } + #[test] fn provider_strategy_round_trips_through_its_config_id() { assert_eq!(RouteStrategy::from_id("provider"), RouteStrategy::Provider); diff --git a/desktop-tauri/src-tauri/server/src/server/core/routing_groups.rs b/desktop-tauri/src-tauri/server/src/server/core/routing_groups.rs index a8310de33..777716590 100644 --- a/desktop-tauri/src-tauri/server/src/server/core/routing_groups.rs +++ b/desktop-tauri/src-tauri/server/src/server/core/routing_groups.rs @@ -138,18 +138,32 @@ pub fn project_with_vision(group: &RoutingGroup, accounts: &[Value], needs: &Req "providerLabel": providers::label_of(&member.provider), "model": actual, "name": actual, "state": "unavailable", "reason": reason })); continue; } + // 成员的参与账号:**空名单 = 该提供商的全部可用账号**(#644「全加入路由」)。 + // 少勾一个账号就等于少一条退路;路由组不该因为漏选而在失败时静默少候选。 + let mut candidates: Vec<(String, Value)> = Vec::new(); if member.accounts.is_empty() { - result.blocked.push(json!({ "id": member.id, "memberId": member.id, "provider": member.provider, "model": actual, - "name": actual, "state": "excluded", "reason": "该成员没有参与账号" })); - } - for id in &member.accounts { - let Some(account) = by_id.get(id.as_str()).filter(|account| routing::provider_of(account) == member.provider) else { - result.blocked.push(json!({ "id": id, "memberId": member.id, "provider": member.provider, "model": actual, - "name": id, "state": "unavailable", "reason": "参与账号已移除或不属于此提供商" })); + for account in accounts.iter().filter(|account| routing::provider_of(account) == member.provider + && account.get("enabled") != Some(&Value::Bool(false))) { + if let Some(id) = routing::account_id(account) { + candidates.push((id.to_string(), (*account).clone())); + } + } + if candidates.is_empty() { + result.blocked.push(json!({ "id": member.id, "memberId": member.id, "provider": member.provider, "model": actual, + "name": actual, "state": "excluded", "reason": "该提供商没有可用账号" })); continue; - }; - let mut account = (*account).clone(); - account["routingCandidateId"] = candidate_key(&member.id, id).into(); + } + } else { + for id in &member.accounts { + match by_id.get(id.as_str()).filter(|account| routing::provider_of(account) == member.provider) { + Some(account) => candidates.push((id.clone(), (*account).clone())), + None => result.blocked.push(json!({ "id": id, "memberId": member.id, "provider": member.provider, "model": actual, + "name": id, "state": "unavailable", "reason": "参与账号已移除或不属于此提供商" })), + } + } + } + for (id, mut account) in candidates { + account["routingCandidateId"] = candidate_key(&member.id, &id).into(); account["routingMemberId"] = member.id.clone().into(); account["routingModel"] = actual.clone().into(); account["routingPriority"] = result.accounts.len().into(); @@ -181,9 +195,15 @@ pub fn append_public(store: &AccountStore, scope: Option<&KeyScope>, data: &mut for group in config::routing_profiles().groups.values() { if !key_scope::allows_model(scope, &group.model) || data.iter().any(|item| model_id(item).eq_ignore_ascii_case(&group.model)) { continue; } let members: Vec<_> = group.members.iter().filter(|member| member.included && key_scope::allows_provider(scope, &member.provider) - && provider_active(&member.provider) - && accounts.available_providers.contains(&member.provider) && member.accounts.iter().any(|id| - accounts.accounts.iter().any(|account| routing::account_id(account) == Some(id) && routing::provider_of(account) == member.provider && account.get("enabled") != Some(&Value::Bool(false))))) + && provider_active(&member.provider) && accounts.available_providers.contains(&member.provider) + && if member.accounts.is_empty() { + // 空名单 = 该提供商的全部账号(与 `project` 同口径) + accounts.accounts.iter().any(|account| routing::provider_of(account) == member.provider + && account.get("enabled") != Some(&Value::Bool(false))) + } else { + member.accounts.iter().any(|id| accounts.accounts.iter().any(|account| routing::account_id(account) == Some(id) + && routing::provider_of(account) == member.provider && account.get("enabled") != Some(&Value::Bool(false)))) + }) .filter_map(|member| catalog_model(&member.provider, &member.model)).filter(|item| !providers::images::model_is_image(item)).collect(); if members.is_empty() { continue; } let mut item = json!({ "id": group.model, "name": group.name, "object": "model", "owned_by": "routing-group", "kind": "chat", "routing_group": true }); diff --git a/desktop-tauri/src-tauri/server/src/server/core/upstream/account_admission.rs b/desktop-tauri/src-tauri/server/src/server/core/upstream/account_admission.rs index 153f4f982..54b67be7c 100644 --- a/desktop-tauri/src-tauri/server/src/server/core/upstream/account_admission.rs +++ b/desktop-tauri/src-tauri/server/src/server/core/upstream/account_admission.rs @@ -16,6 +16,10 @@ pub(super) async fn select(service: &UpstreamService, providers: &[&str], keys: let wait_started = Instant::now(); let deadline = wait_started + Duration::from_secs(wait_seconds); let mut excluded = tried.to_vec(); + // 最后一轮选路拿到的决策快照:排队超时也要把「当时谁可试、谁被什么挡住」 + // 带回转发层落库,否则请求日志里只剩一句「账号均忙」,看不出是并发满还是 + // 冷却/熔断/模型权限把它挡掉的。 + let mut last_snapshot: Option = None; let notify = service.connections().changed_notify(); loop { let wake = notify.notified(); @@ -26,6 +30,7 @@ pub(super) async fn select(service: &UpstreamService, providers: &[&str], keys: match selected { Ok(target) if target.account_id.is_none() && excluded.len() > tried.len() => {}, Ok(target) => { + if let Some(decision) = &target.decision { last_snapshot = Some(decision.clone()); } let limit = target.account.as_ref().map(crate::server::core::routing::max_concurrent_of).unwrap_or(0); if connection.try_rebind(target.account_id.clone(), limit) { return Ok(target); } if pinned.is_none() { @@ -33,13 +38,20 @@ pub(super) async fn select(service: &UpstreamService, providers: &[&str], keys: if excluded.len().saturating_sub(tried.len()) < 32 { continue; } } } - Err(error) if error.code.as_deref() == Some("account_busy") || excluded.len() > tried.len() => {}, - Err(error) => return Err(error), + Err(error) => { + if let Some(snapshot) = error.route_snapshot() { last_snapshot = Some(snapshot.clone()); } + if !(error.code.as_deref() == Some("account_busy") || excluded.len() > tried.len()) { + return Err(error); + } + } } connection.rebind(None); - if Instant::now() >= deadline { - return Err(busy_timeout(providers, tried.len(), wait_started.elapsed(), wait_seconds)); - } + let timed_out = || { + let mut error = busy_timeout(providers, tried.len(), wait_started.elapsed(), wait_seconds); + if let Some(snapshot) = &last_snapshot { error = error.with_route_snapshot(snapshot.clone()); } + error + }; + if Instant::now() >= deadline { return Err(timed_out()); } let token = telemetry.cancel_token(); tokio::select! { biased; @@ -47,7 +59,7 @@ pub(super) async fn select(service: &UpstreamService, providers: &[&str], keys: return Err(cancellation::cancelled_error()); } _ = tokio::time::sleep_until(deadline) => { - return Err(busy_timeout(providers, tried.len(), wait_started.elapsed(), wait_seconds)); + return Err(timed_out()); } _ = &mut wake => {}, _ = tokio::time::sleep(Duration::from_millis(100)) => {}, diff --git a/desktop-tauri/src-tauri/server/src/server/core/upstream/error_policy.rs b/desktop-tauri/src-tauri/server/src/server/core/upstream/error_policy.rs index 66ee2c54f..e9c9f01fd 100644 --- a/desktop-tauri/src-tauri/server/src/server/core/upstream/error_policy.rs +++ b/desktop-tauri/src-tauri/server/src/server/core/upstream/error_policy.rs @@ -55,8 +55,14 @@ pub(crate) fn decide_with(snapshot: &config::ErrorPolicySnapshot, provider: &str status: u16, body: &Value, local: bool, explicit_stop: bool) -> ErrorDecision { let settings = &snapshot.settings; let code = evidence::machine_code(body); - let kind = evidence::kind(provider, class, status, &code); - let rule = settings.resolve(kind, status, &code, provider, model).clone(); + let mut kind = evidence::kind(provider, class, status, &code); + // 429/402 里包着的「积分/余额/套餐」按文案还原(见 `evidence::resource_kind`): + // 这类是账号级资源耗尽,方向是「排掉这个账号、换下一家」,而不是「等一会儿 + // 在同一账号重试」。不还原的话,路由组会拿同一个账号换着成员模型再撞一次。 + if matches!(kind, ErrorKind::RateLimit | ErrorKind::Quota | ErrorKind::Balance | ErrorKind::Unknown) { + if let Some(actual) = evidence::resource_kind(body.get("message").and_then(Value::as_str).unwrap_or("")) { kind = actual; } + } + let mut rule = settings.resolve(kind, status, &code, provider, model).clone(); let upstream_scope = evidence::scope(body); let mut scope = match (rule.scope, upstream_scope) { (_, CooldownScope::Provider) => CooldownScope::Provider, @@ -65,11 +71,32 @@ pub(crate) fn decide_with(snapshot: &config::ErrorPolicySnapshot, provider: &str (scope, _) => scope, }; let account_model = matches!(code.as_str(), "account_model_unavailable" | "account_model_permissions_unknown" | "model_not_available_for_account"); - let hard_stop = explicit_stop || evidence::hard_stop(status, &code) - || matches!(kind, ErrorKind::BadRequest | ErrorKind::Content) - || local && status == 501 && !account_model && !matches!(code.as_str(), "unsupported" | "no_method" | "not_implemented" - | "route_not_supported" | "subscription_sharing_route_not_supported" | "subscription_sharing_unsupported_capability"); + // 「请求有误 / 内容被拒」不再写死成硬终止(#644):默认它们也换号, + // 因为换一家/换一个账号的审核与参数兼容性仍可能不同。想让它们直接回到 + // 下游,用例外名单(`overrides` 里的 `ReturnError`)显式表达。 + let hard_stop = explicit_stop || evidence::hard_stop(status, &code); let mut action = if hard_stop { ErrorAction::ReturnError } else { rule.action }; + // 没有拿到上游响应(status 0)= 链路/本地问题:换账号解决不了,避免把 + // 整个候选队列当成「试错池」白打一遍。 + if status == 0 { action = ErrorAction::ReturnError; } + // ── 本地就判定「这家吃不下这份请求」─────────────────────── + // 典型是网页工具(`toolEmulation`)按模型预算在**本机**判定的 400: + // `网页工具请求超过 16000 字符预算`。这类结论与账号无关 —— 同一家的 + // 另一个账号拿到的是同一份 body、同一个预算,撞的是同一堵墙。逐个账号 + // 试过去只会把换号预算烧在同一家身上,让真正能答上来的候选(例如不做 + // 工具模拟的模型)永远轮不到。 + // + // 所以这里升级成「跳过这家」:本次请求里把这家其余账号一并排除(见 + // `ErrorDecision::skips_provider`),同时给失败的 账号×模型 记一段冷却, + // 让下一条请求也不会先撞一次。冷却只落在模型维度,不是整家拉黑 —— + // 这家别的模型仍可能正常。 + let provider_local = matches!(kind, ErrorKind::BadRequest | ErrorKind::Unsupported) + && (evidence::provider_local(&code) || (local && matches!(status, 400 | 413 | 415 | 422 | 501))); + if provider_local && action != ErrorAction::ReturnError { + action = ErrorAction::SwitchProvider; + if scope == CooldownScope::Provider { scope = CooldownScope::Model; } + if rule.cooldown == CooldownMode::None { rule.cooldown = CooldownMode::Fixed; } + } if account_model { scope = CooldownScope::Model; if action == ErrorAction::SwitchProvider { action = ErrorAction::SwitchAccount; } @@ -77,6 +104,13 @@ pub(crate) fn decide_with(snapshot: &config::ErrorPolicySnapshot, provider: &str if matches!(kind, ErrorKind::Auth | ErrorKind::Balance) && rule.scope == CooldownScope::Auto && scope != CooldownScope::Provider { scope = CooldownScope::Account; } + // 限流 / 额度 / 余额消耗的是**账号**的池子,不是某个模型的独立额度:冷却和 + // 本次请求的排除都按账号维度走。上游若声成整家共享(Provider)则保留, + // 其余(含上游写 `scope: model` 的)一律升到账号级 —— 否则同一个账号会 + // 被路由组的不同成员模型各撞一次,日志里就是「连着两个 429 没换模型」。 + if matches!(kind, ErrorKind::RateLimit | ErrorKind::Quota) && scope != CooldownScope::Provider && !account_model { + scope = CooldownScope::Account; + } if kind != ErrorKind::Auth && action == ErrorAction::RefreshThenSwitch { action = ErrorAction::ReturnError; } let now = logging::now_ms(); let mut reset_at = evidence::reset(body, now); @@ -119,13 +153,26 @@ pub(super) fn classified_error(class: &UpstreamErrorClass, body: &Value) -> Gate error } -pub(super) fn plugin_stops(provider: &str, policy: &crate::server::core::providers::policy::ErrorPolicy, - class: &UpstreamErrorClass, status: u16, body: &Value) -> bool { +/// 插件报的 `stop` 是否等于「这家别再原样发」。 +/// +/// ── `stop` 不等于「整条请求到此为止」(#644,2026-11-21 再收窄一次)── +/// 插件声明 `stop` 的本义是「这份 body 不要再往这家重发」。曾经的实现把它当成 +/// 硬终止:账号级失败(被封、限额、WAF、渠道未授权)静默收尾,队列里明明还有 +/// 健康账号与别的提供商却一个都不试。实测 21:34 一条 `pro` 组请求就是被 +/// WorkBuddy 的 400「unapproved channel」+ `stop_switching` 掐断的,下游拿到 +/// 400,而同一时刻另外几家都能答。 +/// +/// 现在调用方(`error_policy_send`)把这里的返回值解释成 **跳过这一家** +/// (`SwitchProvider`),只有 `evidence::hard_stop` 那类证据判据(重复执行 / +/// 重复计费 / 已取消)才算真正的硬终止 —— 它由 [`decide_with`] 自己按证据 +/// 打开,与本函数的返回值无关。 +/// +/// `suspend_account` 不进这里 —— 停用当前账号之后,正该换下一个账号继续。 +pub(super) fn plugin_stops(_provider: &str, policy: &crate::server::core::providers::policy::ErrorPolicy, + _class: &UpstreamErrorClass, status: u16, body: &Value) -> bool { if !policy.stop { return false; } let code = evidence::machine_code(body); - let unsupported = evidence::kind(provider, class, status, &code) == ErrorKind::Unsupported; - policy.suspend_account || policy.stop_switching - || evidence::hard_stop(status, &code) || !unsupported + policy.stop_switching || evidence::hard_stop(status, &code) } pub(super) fn attach(error: &mut GatewayError, decision: &ErrorDecision) { @@ -165,3 +212,163 @@ pub(super) fn exclude_provider(service: &super::UpstreamService, providers: &[&s } } } + +#[cfg(test)] +mod tests { + use super::*; + use crate::server::config::error_policy::{ + default_rules, CooldownMode, ErrorAction, ErrorKind, ErrorPolicySnapshot, ErrorSettings, + }; + + fn snapshot() -> ErrorPolicySnapshot { + ErrorPolicySnapshot { settings: ErrorSettings::default(), configured: true, legacy: false } + } + + fn fatal(status: u16, message: &str) -> UpstreamErrorClass { + UpstreamErrorClass::Fatal { status, message: message.into(), upstream_code: None } + } + + fn decide(status: u16, body: serde_json::Value) -> ErrorDecision { + decide_with(&snapshot(), "demo", "demo-model", &fatal(status, "upstream said no"), status, &body, false, false) + } + + /// 429 默认就是「冷却这个账号 × 模型,然后换下一个候选」。 + #[test] + fn rate_limit_switches_and_cools_down() { + let decision = decide(429, serde_json::json!({ "message": "too many requests" })); + assert_eq!(decision.kind, ErrorKind::RateLimit); + assert_eq!(decision.action, ErrorAction::SwitchAccount); + assert!(decision.switches() && decision.cooldown()); + } + + /// 上游 403(被封 / 无权)属于账号级结论,必须顺延而不是收尾。 + #[test] + fn forbidden_switches_instead_of_stopping() { + let decision = decide(403, serde_json::json!({ "code": "forbidden" })); + assert!(!decision.hard_stop, "403 不再算硬终止"); + assert_eq!(decision.action, ErrorAction::SwitchAccount); + assert!(decision.switches()); + } + + /// 5xx 不再原地重发,第一次失败就换候选。 + #[test] + fn transient_does_not_resend_in_place() { + let decision = decide(502, serde_json::json!({ "message": "bad gateway" })); + assert_eq!(decision.kind, ErrorKind::Transient); + assert!(!decision.retries(), "默认不做同一账号原地重发"); + assert_eq!(decision.action, ErrorAction::SwitchAccount); + } + + /// 请求本身有误也换号(有别的候选仍可能成功),并留一段短冷却 —— + /// 「限制器」的意义:刚在这个 账号×模型 上失败过的组合,别让下一条请求 + /// 又抢着试一遍。 + #[test] + fn bad_request_switches_and_cools_briefly() { + let decision = decide(400, serde_json::json!({ "code": "invalid_request" })); + assert_eq!(decision.kind, ErrorKind::BadRequest); + assert_eq!(decision.action, ErrorAction::SwitchAccount); + assert!(decision.switches()); + assert!(decision.cooldown(), "请求有误也要落一段冷却,避免反复挑中同一个坏组合"); + assert_eq!(decision.scope, CooldownScope::Model, "冷却只落在模型维度,不整家拉黑"); + } + + /// 例外名单(旧「指定错误码」键,语义已反转为「允许透传下游」)命中时 + /// 不再换号,直接把错误交回客户端。 + #[test] + fn passthrough_exception_returns_error() { + let mut settings = ErrorSettings::default(); + let mut rule = default_rules().into_iter().find(|rule| rule.kind == ErrorKind::BadRequest).unwrap(); + rule.id = "legacy-400".into(); + rule.name = "原错误码名单例外 400".into(); + rule.statuses = vec![400]; + rule.action = ErrorAction::ReturnError; + rule.cooldown = CooldownMode::None; + settings.overrides.push(rule); + let snapshot = ErrorPolicySnapshot { settings, configured: true, legacy: false }; + let decision = decide_with(&snapshot, "demo", "demo-model", + &fatal(400, "upstream said no"), 400, &serde_json::json!({ "code": "invalid_request" }), false, false); + assert_eq!(decision.action, ErrorAction::ReturnError); + assert!(!decision.switches(), "命中例外就不该再换号"); + } + + /// 网页工具预算超限是**本地**按模型 profile 判定的 400:同一家的另一个 + /// 账号拿到的是同一份 body、同一个预算,撞的是同一堵墙。所以要直接跳过 + /// 这一家(而不是把预算逐个账号烧下去),并给失败的 账号×模型 记冷却。 + #[test] + fn web_tools_budget_error_skips_provider() { + let decision = decide(400, serde_json::json!({ "code": "web_tools_invalid_request" })); + assert_eq!(decision.action, ErrorAction::SwitchProvider); + assert!(decision.switches(), "跳过这一家也要继续顺延"); + assert!(decision.skips_provider(), "本次请求不该再试这一家的其他账号"); + assert!(decision.cooldown(), "失败组合要落冷却,别让下一条请求再撞一次"); + assert_eq!(decision.scope, CooldownScope::Model); + } + + /// 真正「本地构造就失败」的 400(`local = true`)同样按跳过这家处理。 + #[test] + fn local_build_failure_skips_provider() { + let decision = decide_with(&snapshot(), "demo", "demo-model", + &fatal(400, "网页工具请求超过 16000 字符预算"), 400, &serde_json::json!({}), true, false); + assert_eq!(decision.action, ErrorAction::SwitchProvider); + assert!(decision.skips_provider()); + } + + /// 429 里包着的「积分余额不足」(聚合上游常把它套在 429 上)是账号级资源 + /// 耗尽:按账号冷却,本次请求把这个账号的其余候选一起排掉 —— 否则路由组会 + /// 拿同一个账号换着成员模型再撞一次,日志里就是连着两条 429。 + #[test] + fn balance_wrapped_in_429_cools_account() { + let decision = decide(429, serde_json::json!({ "message": "上游返回 429: 上游返回 402: 积分余额不足,请获取积分后再试" })); + assert_eq!(decision.kind, ErrorKind::Balance); + assert_eq!(decision.action, ErrorAction::SwitchAccount); + assert_eq!(decision.scope, CooldownScope::Account, "账号级资源耗尽要按账号冷却"); + assert!(decision.switches() && decision.cooldown()); + } + + /// 「套餐池没有有效套餐」同理:账号级额度,不是某一个模型的额度。 + #[test] + fn subscription_quota_cools_account() { + let decision = decide(429, serde_json::json!({ "message": "ZCode 套餐池当前没有有效套餐(1005)" })); + assert_eq!(decision.kind, ErrorKind::Quota); + assert_eq!(decision.scope, CooldownScope::Account); + assert!(decision.cooldown()); + } + + /// 真正的频率限制也按账号冷却(限流消耗的是账号的池子)。 + #[test] + fn rate_limit_cools_account() { + let decision = decide(429, serde_json::json!({ "message": "too many requests, rate limit exceeded" })); + assert_eq!(decision.kind, ErrorKind::RateLimit); + assert_eq!(decision.scope, CooldownScope::Account); + } + + /// 但上游明确声明整家共享冷却时保留 Provider,不缩到账号级。 + #[test] + fn provider_scope_is_preserved_for_rate_limit() { + let decision = decide(429, serde_json::json!({ "message": "rate limit exceeded", "credentialScope": "provider" })); + assert_eq!(decision.scope, CooldownScope::Provider); + } + + /// 没有拿到上游响应(status 0)是链路问题:换账号解决不了,保持收尾。 + #[test] + fn transport_failure_does_not_switch() { + let decision = decide(0, serde_json::json!({ "message": "connect error" })); + assert_eq!(decision.action, ErrorAction::ReturnError); + assert!(!decision.switches()); + } + + /// 插件报 `stop` 只表示「别再原地重发」,不再顺手掐掉换号。 + #[test] + fn plugin_stop_does_not_block_switching() { + let policy = crate::server::core::providers::policy::ErrorPolicy { + stop: true, stop_switching: false, account_cooldown_until: None, suspend_account: false, + reason: String::new(), + }; + assert!(!plugin_stops("demo", &policy, &fatal(503, "busy"), 503, &serde_json::json!({}))); + let explicit = crate::server::core::providers::policy::ErrorPolicy { + stop: true, stop_switching: true, account_cooldown_until: None, suspend_account: false, + reason: String::new(), + }; + assert!(plugin_stops("demo", &explicit, &fatal(503, "busy"), 503, &serde_json::json!({}))); + } +} diff --git a/desktop-tauri/src-tauri/server/src/server/core/upstream/error_policy_evidence.rs b/desktop-tauri/src-tauri/server/src/server/core/upstream/error_policy_evidence.rs index 94305ffa6..4e34fccc8 100644 --- a/desktop-tauri/src-tauri/server/src/server/core/upstream/error_policy_evidence.rs +++ b/desktop-tauri/src-tauri/server/src/server/core/upstream/error_policy_evidence.rs @@ -48,8 +48,40 @@ pub(super) fn kind(provider: &str, class: &UpstreamErrorClass, status: u16, code ErrorKind::Unknown } -pub(super) fn scope(body: &Value) -> CooldownScope { - match body.get("credentialScope").or_else(|| body.get("credential_scope")).or_else(|| body.get("scope")).and_then(Value::as_str) { +/// 「这份 body 本身就发不出去」的本地业务码 —— 换账号无用,得换一家。 +/// 这些码由本机在**发送前**生成(网页工具的字符预算、视觉兼容的前置校验), +/// 它们的结论是「提供商 × 模型能力吃不下这份请求」,与具体账号无关。 +/// 判据按码前缀匹配:新增同类能力检查时只要沿用同一前缀,就自动获得 +/// 「跳过这一家 + 落模型冷却」的处置。 +pub(super) fn provider_local(code: &str) -> bool { + ["web_tools_", "vision_", "native_payload_"].iter().any(|prefix| code.starts_with(prefix)) +} + +/// 429/402 里包着的「账号资源已经用完」语义,按**文案**还原成真正的错误类型。 +/// +/// 聚合类上游常把余额/套餐问题套在 429 里返回,例如: +/// `上游返回 429: 上游返回 402: 积分余额不足,请获取积分后再试`、 +/// `ZCode 套餐池当前没有有效套餐(1005)`。只按状态码归成「请求限流」会让 +/// 处置方向错掉 —— 限流是「等一会儿还能用」,余额/套餐是「这个账号暂时 +/// 不可能答」,后者必须按**账号级**冷却并把该账号的其余候选一起排掉, +/// 否则路由组会拿同一个账号换着模型再撞一次(429 连着两条就是这么来的)。 +/// +/// 返回 `None` 表示文案看不出资源问题(例如真正的频率限制),保持原分类。 +pub(super) fn resource_kind(message: &str) -> Option { + let text = message.to_lowercase(); + // 明确的频率限制优先排除:文案里常同时出现「额度」「quota」这类词。 + const RATE: [&str; 5] = ["rate limit", "rate_limit", "too many requests", "限流", "频率限制"]; + if RATE.iter().any(|word| text.contains(word)) { return None; } + const BALANCE: [&str; 8] = ["积分余额不足", "积分不足", "余额不足", "欠费", "insufficient balance", "insufficient credit", + "credit balance", "payment required"]; + if BALANCE.iter().any(|word| text.contains(word)) { return Some(ErrorKind::Balance); } + const QUOTA: [&str; 9] = ["套餐池", "没有有效套餐", "套餐到期", "套餐已到期", "额度已用尽", "quota", "usage limit", + "配额不足", "quota exceeded"]; + if QUOTA.iter().any(|word| text.contains(word)) { return Some(ErrorKind::Quota); } + None +} + +pub(super) fn scope(body: &Value) -> CooldownScope { match body.get("credentialScope").or_else(|| body.get("credential_scope")).or_else(|| body.get("scope")).and_then(Value::as_str) { Some("provider") => CooldownScope::Provider, Some("account" | "credential" | "subscription" | "oauth" | "token") => CooldownScope::Account, _ => CooldownScope::Model, @@ -100,16 +132,32 @@ pub(in crate::server::core::upstream) fn gateway_class(error: &GatewayError) -> }) } +/// 「不要再换号、直接把错误交回下游」的硬终止判据。 +/// +/// ── 为什么 403 / 权限类不再在这里 ───────────────────────── +/// 上游 403(账号被风控、凭证对该模型无权、订阅级禁止)是**账号级**结论: +/// 换下一个账号或另一家仍可能成功,属于「应该顺延」而不是「整条请求没救」。 +/// #644 之后它们走默认的换号规则(并落账号级冷却/熔断)。 +/// +/// ── 为什么「忙 / 插件协议错 / 插件崩了 / 原生助手不可用」也不再在这里 +/// (2026-11-21 再收窄)──────────────────────────────────── +/// 它们的共同点是「这一次没发出去,或者这次失败与账号无关」—— +/// 而这两点恰恰是**换一个候选仍然有救**,不是「这条请求到此为止」。 +/// 实测:一条 `pro` 组请求在 WorkBuddy 回 400「Illegal API invocation from an +/// unapproved channel」后**没有任何换号动作**(明细里那一轮的 `errorPolicy` 是 +/// null,统一规则压根没跑),下游拿到 400;同一时刻 autoclaw / codearts / quwork +/// 都还能答。旧列表把 `plugin_protocol_error` / `plugin_trap` / `*_busy` / +/// `runtime_upstream_error` 全归成硬终止,等于「插件一抖,整条请求就死」。 +/// +/// 现在只保留「再发一次可能造成重复执行 / 重复计费 / 状态错乱」与「用户已取消」 +/// 两类 —— 这是唯一不能靠换候选解决的失败形态。 pub(super) fn hard_stop(status: u16, code: &str) -> bool { - matches!(status, 403 | 409 | 428 | 499) - || code.ends_with("cleanup_unconfirmed") || code.starts_with("claude_session_") - || matches!(code, "permission_denied" | "access_denied" | "permission_error" | "validation_required" - | "tabbit_submission_unconfirmed" | "tabbit_account_changed" | "tabbit_state_conflict" - | "claude_response_started" | "account_origin_authorization_required" - | "plugin_busy" | "gateway_busy" | "account_busy" | "plugin_response_started" | "plugin_resource_limit" - | "plugin_protocol_error" | "plugin_trap" | "forbidden" | "native_helper_not_authorized" | "native_helper_unavailable" - | "request_replay_blocked" | "web_tools_invalid_request" | "gateway_capability_missing" | "aborted" | "cancelled" - | "upstream_submission_unconfirmed" | "runtime_invalid_error_metadata" | "runtime_protocol_error" | "runtime_stream_interrupted" - | "runtime_classification_unavailable" | "runtime_transport_unavailable" | "network_cleanup_unconfirmed" - | "runtime_upstream_error" | "builtin_runtime_error" | "runtime_sdk_content") + matches!(status, 409 | 428 | 499) + || code.ends_with("cleanup_unconfirmed") + || code.contains("unconfirmed") + || code.starts_with("claude_session_") + || matches!(code, "validation_required" + // 响应字节已经在往客户端写:此刻换号只会让下游收到半条流 + 另一家的续文 + | "claude_response_started" | "plugin_response_started" | "runtime_stream_interrupted" + | "request_replay_blocked" | "aborted" | "cancelled") } diff --git a/desktop-tauri/src-tauri/server/src/server/core/upstream/error_policy_finish.rs b/desktop-tauri/src-tauri/server/src/server/core/upstream/error_policy_finish.rs index d9d98b012..bc92d68e9 100644 --- a/desktop-tauri/src-tauri/server/src/server/core/upstream/error_policy_finish.rs +++ b/desktop-tauri/src-tauri/server/src/server/core/upstream/error_policy_finish.rs @@ -8,7 +8,24 @@ use super::{error_policy, rotate, RouteTarget, UpstreamService}; use super::payload::ProviderContext; pub(super) fn finish_failure(service: &UpstreamService, ctx: &ProviderContext<'_>, providers: &[&str], keys: &rotate::CooldownKeys<'_>, - target: &RouteTarget, error: &mut GatewayError, tried: &mut Vec, switches_left: &mut usize, switch_total: usize) -> bool { + target: &RouteTarget, error: &mut GatewayError, tried: &mut Vec, switches_left: &mut usize, switch_total: usize, + conv_key: &str, sticky_model: &str, sticky_generation: u64) -> bool { + // 失败即解除会话绑定:粘性只在成功时建立,绑着一个刚失败的候选只会让 + // 同一会话的下一条请求先撞一次同样的错误(429 时表现为「每次都先吃一个 + // 429」)。解绑放在最前面 —— 哪怕这一次最终收尾(hard_stop / 无候选), + // 也不该把失败账号继续粘在这个会话上。 + if let Some(candidate) = target.attempt_key() { + service.route.sticky_forget(conv_key, sticky_model, &candidate, sticky_generation); + } + // 面包屑:这一行出现 ⇒ 统一错误规则确实跑到了;没出现 ⇒ 这个错误是某个 + // 早退分支直接抛回下游的(那时明细里的 `errorPolicy` 会是 null)。 + // 用 `log_with_level` 而不是 `console_line`:前者会落进数据库的 `logs` 表, + // 事后能直接查;`console_line` 只打到 stdout,没截屏就等于丢了。 + logging::log_with_level("[Upstream]", &format!( + "错误结算 provider={} status={} 模型={} 已试={} 账号={}", + target.provider, error.status_code, + target.account.as_ref().and_then(|a| a["routingModel"].as_str()).unwrap_or("-"), + tried.len(), target.account_id.as_deref().unwrap_or("-")), "info"); let model = error.routing_error.as_ref().map(|decision| decision.model.clone()).unwrap_or_else(|| { target.account.as_ref().map(|account| keys.for_account(account)).unwrap_or_else(|| keys.for_provider(&target.provider)) }); @@ -16,7 +33,42 @@ pub(super) fn finish_failure(service: &UpstreamService, ctx: &ProviderContext<'_ let decision = error.routing_error.clone().unwrap_or_else(|| error_policy::for_error_with(&ctx.error_policy, &target.provider, &model, error, false)); error_policy::attach(error, &decision); error_policy::note(ctx.telemetry, &decision, None); - if decision.hard_stop || ctx.telemetry.replay_guard().blocked() || ctx.telemetry.is_cancelled() || ctx.telemetry.response_started() { return false; } + // ── 「为什么没有再往下换一个」必须留在控制台 ───────────────────── + // 以前这些理由只写进 `note_error_policy`(随 attempt 明细落库)。可一旦 + // attempt 记录先被 `finish_last_attempt` 收尾,note 就无处可写 —— 库里的 + // `errorPolicy` 成了 null,面板上只剩「上游 400」,看不出是「规则不让换」 + // 还是「确实没有下一个」。实测 22:49 那条 400 就是这样:账号被铺了冷却 + // (说明这里跑过了),但明细里 policy=null,谁也没法解释为什么停住。 + let model_label = model.clone(); + // 错误正文先取成字符串:闭包不能借用 `error`(后面还要改 `retry_after_secs`)。 + let head = format!("HTTP {} {}", error.status_code, error.message); + let stop = |reason: &str| { + ctx.telemetry.note_error_policy(json!({ "reason": reason })); + logging::log_with_level("[Upstream]", &format!( + "未继续顺延({head} · 模型 {model_label}):{reason}"), "warn"); + false + }; + // ── 「这家吃不下这份请求」要把整家铺上冷却,而不是只罚撞墙的那个账号 ── + // provider_local 的 400(网页工具预算超限、该家不接受的参数)与账号无关: + // 同一家的另一个账号拿到的是同一份 body、同一个预算,撞的是同一堵墙。只给 + // 失败账号记冷却的话,下一条请求会派同家的下一个账号再吃一次一模一样的 + // 400 —— 用户看到的就是「前面报过错的没有被熔断,后续请求继续往上撞」。 + // 冷却键仍是模型维度(这家别的模型照常可用),但铺到该家的全部账号。 + if decision.skips_provider() && decision.scope == crate::server::config::error_policy::CooldownScope::Model + && ctx.pinned_account.is_none() { + for account in rotate::scoped_accounts(service, providers, keys.request_model(), None, Some(&ctx.routing)) { + if crate::server::core::routing::provider_of(&account) != target.provider { continue; } + let Some(id) = crate::server::core::routing::account_id(&account) else { continue }; + if Some(id) == target.account_id.as_deref() { continue; } + error_policy::remember_cooldown(service, settings, id, &model, error, &decision); + } + } + if decision.hard_stop { + return stop(&format!("规则「{}」判定为硬终止,不再换对象", decision.rule.name)); + } + if ctx.telemetry.replay_guard().blocked() || ctx.telemetry.is_cancelled() || ctx.telemetry.response_started() { + return stop("回放拦截 / 已取消 / 响应已开始下发"); + } if let Some(account) = target.account_id.as_deref() { if let Some(entry) = error_policy::remember_cooldown(service, settings, account, &model, error, &decision) { let reset = entry["resetAt"].as_i64().unwrap_or(0); @@ -26,17 +78,53 @@ pub(super) fn finish_failure(service: &UpstreamService, ctx: &ProviderContext<'_ if matches!(decision.kind, ErrorKind::RateLimit | ErrorKind::Quota) && settings.sink && ctx.pinned_account.is_none() { service.route.sink_mark_for(account, logging::now_ms(), settings.sink_seconds); } - if decision.kind == ErrorKind::Transient && decision.rule.cooldown == crate::server::config::error_policy::CooldownMode::Protection { - if settings.backoff { service.route.backoff_mark_for(account, logging::now_ms(), settings.backoff_seconds, settings.backoff_cap_seconds); } - if settings.breaker { - service.route.breaker_failure(account, settings.breaker_failures as i64, settings.breaker_seconds as i64, logging::now_ms()); + // ── 上游说「余额/积分不足」→ 把本地余额读数按 0 落一次 ────────── + // 余额是查上游接口读回来的,字段形状一变就会读出一个明显偏高的数字; + // 限制器与低余额跳过都按这个数字判断,于是账号一直显得「有钱」,每条 + // 请求都被派上去再吃一次 402「积分余额不足」。上游的 402 比本地读数更 + // 权威:这里直接落 0,余额列显示 0、低余额规则立刻拦下它,充值后下一 + // 次成功查询会自己把 0 顶掉。 + if decision.kind == ErrorKind::Balance { + crate::server::core::usage_records::force_zero_balance( + account, "上游报余额不足,余额读数已按 0 处理;充值后自动恢复"); + } + if decision.kind == ErrorKind::Transient && decision.rule.cooldown == crate::server::config::error_policy::CooldownMode::Protection + && settings.backoff { + service.route.backoff_mark_for(account, logging::now_ms(), settings.backoff_seconds, settings.backoff_cap_seconds); + } + // ── 失败计数与熔断:任何一次失败都算,不分错误类型 ────────────── + // 以前只在「连接或服务异常」上计数,于是 401 / 400 / 429 的账号永远不会 + // 真正「熔断」——冷却一到期又回到队首,下一次请求继续撞同一堵墙。用户 + // 的口径是「失败的账号就该熔断,然后轮换到其他供应商」:所以这里把每次 + // 失败都记进去,连续失败到阈值就把这个账号从轮转里摘出去一段时间 + // (`plan_route` 的 `open` 集合),别的家才有机会接活。 + if settings.breaker { + // 登录失效一次就熔断:401 是「上游不认这个登录态」,续期又没救回来, + // 再试一次只会再 401 一次 —— 立刻摘出轮转,别等攒够阈值。 + let threshold = if decision.kind == ErrorKind::Auth { 1 } else { settings.breaker_failures as i64 }; + let opened = service.route.breaker_failure( + account, threshold, settings.breaker_seconds as i64, logging::now_ms()); + if opened { + let label = target.account.as_ref().map(super::account_display).unwrap_or_default(); + logging::console_line("[Upstream]", &format!( + "账号「{label}」失败达 {threshold} 次,熔断 {} 秒后才会重新进入轮转", settings.breaker_seconds)); + ctx.telemetry.note_error_policy(json!({ "reason": "账号连续失败,已熔断" })); } } if decision.kind == ErrorKind::Auth && target.account.as_ref().is_some_and(|account| account["needsRelogin"] == true) { ctx.telemetry.note_error_policy(json!({ "reason": "该账号需要重新登录" })); } } - if !decision.switches() { return false; } + // ── 兜底总闸:不让「规则动作」决定收尾 ──────────────────────────── + // 用户的诉求只有一句:**不管什么错误,先给当前对象记一次限流,再换下一个**, + // 只要队列里还有真正可用(有凭证、已启用、没被限制器拦、没在熔断 / 冷却里) + // 的候选。所以「规则动作是直接返回错误」在这里只留一条日志,不再提前收尾 —— + // 决定收尾的判据只剩下面那一个:「下一个」确实不存在。 + if !decision.switches() { + logging::log_with_level("[Upstream]", &format!( + "规则「{}」本来会直接返回错误(HTTP {}),兜底改为继续换下一个可用对象", + decision.rule.name, error.status_code), "warn"); + } if decision.scope == crate::server::config::error_policy::CooldownScope::Account { if let Some(id) = target.account_id.as_deref() { for candidate in rotate::scoped_accounts(service, providers, keys.request_model(), ctx.pinned_account, Some(&ctx.routing)) { @@ -49,23 +137,32 @@ pub(super) fn finish_failure(service: &UpstreamService, ctx: &ProviderContext<'_ } if let Some(account) = target.account_id.as_deref() { if !rotate::allows_route_skip(service, account) { - ctx.telemetry.note_error_policy(json!({ "reason": "当前账号已关闭失败换号" })); return false; + return stop("该账号在设置里关了「失败换号」"); } } if ctx.pinned_account.is_some() || ctx.routing.requires_account() { - ctx.telemetry.note_error_policy(json!({ "reason": "本次请求明确指定账号,未更换指定对象" })); return false; + return stop("本次请求明确指定账号,不允许换对象"); } if decision.skips_provider() { error_policy::exclude_provider(service, providers, keys.request_model(), &target.provider, tried, ctx.pinned_account, &ctx.routing); } if let Some(id) = target.attempt_key() { tried.retain(|other| other != &id); tried.push(id); } let Some(next) = rotate::pick_next_account(service, providers, keys, tried, ctx.pinned_account, &ctx.routing) else { - ctx.telemetry.note_error_policy(json!({ "reason": "当前路由没有其他可用对象" })); return false; + // 这一句是「池子里到底还有没有下一个」的唯一权威答案:`plan_route` + // 只记录候选,能不能真的拿出一个对象由这次查找决定。走到这里说明剩下 + // 的候选**确实不可用**(限制器拦下 / 熔断中 / 冷却中 / 已禁用 / 无凭证), + // 不是规则把它挡了 —— 兜底也不越过这几条。 + return stop(&format!( + "本队列已没有下一个可用对象(本轮已试 {} 个):剩下的都在冷却、被限制器拦、熔断中、已禁用或无凭证", + tried.len())); }; + // 换号预算用尽同样不作为收尾理由:预算只是「别一口气试太多」的软闸, + // 真正的硬闸是转发层的 `MAX_ROUTE_ATTEMPTS`(100 次)。 if !super::provider_loop::take_switch(switches_left, switch_total) { - ctx.telemetry.note_error_policy(json!({ "reason": "换账号次数已用尽,未继续发送" })); return false; + logging::log_with_level("[Upstream]", &format!( + "换号预算已用尽(上限 {switch_total}),兜底继续换下一个可用对象"), "warn"); } - logging::console_line("[Upstream]", &format!("统一错误规则「{}」:HTTP {},顺延到 {}(换号 {}/{})", - decision.rule.name, error.status_code, super::account_display(&next), switch_total - *switches_left, switch_total)); + logging::log_with_level("[Upstream]", &format!("统一错误规则「{}」:HTTP {},顺延到 {}(换号 {}/{})", + decision.rule.name, error.status_code, super::account_display(&next), switch_total - *switches_left, switch_total), "info"); true } diff --git a/desktop-tauri/src-tauri/server/src/server/core/upstream/error_policy_send.rs b/desktop-tauri/src-tauri/server/src/server/core/upstream/error_policy_send.rs index c86736629..c144dd06e 100644 --- a/desktop-tauri/src-tauri/server/src/server/core/upstream/error_policy_send.rs +++ b/desktop-tauri/src-tauri/server/src/server/core/upstream/error_policy_send.rs @@ -46,7 +46,12 @@ pub(super) async fn send_with_retry( if telemetry.replay_guard().blocked() || telemetry.is_cancelled() { return Err(stopped(if telemetry.is_cancelled() { super::cancellation::cancelled_error() } else { gateway })); } - let decision = error_policy::for_error_with(&budget.policy, adapter.provider_id(), &budget.model, &gateway, !error.safe_to_retry); + let mut decision = error_policy::for_error_with(&budget.policy, adapter.provider_id(), &budget.model, &gateway, !error.safe_to_retry); + // 传输层失败(连不上 / 写不出去 / 读不回来)换成别的账号也一样: + // 这类问题出在本机链路或出口上,换号只会把整个队列白打一遍。 + // 保持「原地处理 + 原样收尾」,与 #644 的口径不冲突 —— 那条规则的 + // 主语是「上游返回的错误」。 + if error.network_failure { decision.action = crate::server::config::error_policy::ErrorAction::ReturnError; } error_policy::attach(&mut gateway, &decision); error_policy::note(telemetry, &decision, None); if decision.hard_stop { @@ -112,9 +117,29 @@ pub(super) async fn send_with_retry( let uncertain = images.is_some() && matches!(class, UpstreamErrorClass::Fatal { .. }) && (status >= 500 || matches!(status, 408 | 409 | 425)); let vision = telemetry.vision_enabled() && super::vision_compat::rejection_message(&detail.message); - let stop = error_policy::plugin_stops(adapter.provider_id(), &policy, &class, status, &body) || uncertain || vision; + // ── 插件声明的「停止」不再等于「整条请求到此为止」(2026-11-21 修正)── + // 实测一条 `pro` 组请求(21:34):WorkBuddy 回 400「Illegal API invocation + // from an unapproved channel」,插件给了 `stop_switching`,旧代码据此把 + // `hard_stop` 打开 —— 于是这条请求在 4 次尝试后**断在 WorkBuddy 上**, + // 明细里这一轮的 `errorPolicy` 是 null(统一规则压根没跑)。可同一时刻 + // 队列里 autoclaw / codearts / quwork 都还能答(下一条请求就是 quwork 200 + // 的),下游却拿到 400。用户的口径是「不管什么原因都要换下一个」。 + // + // 现在的口径:`stop` 只表示「这一家别再原样发」,转成 **跳过提供商** + // (`SwitchProvider`)继续往下走;真正算硬终止的只剩两类 —— + // 结果**可能已经执行过**的(图片 `uncertain` / 视觉兼容 `vision`)与 + // [`error_policy::plugin_stops`] 里 `evidence::hard_stop` 的证据类判据 + // (重复执行 / 重复计费 / 已取消)。后者由 `decide_with` 自己按证据打开, + // 不受这里的 `explicit_stop` 影响。 + let plugin_stop = error_policy::plugin_stops(adapter.provider_id(), &policy, &class, status, &body); let mut decision = error_policy::decide_with(&budget.policy, adapter.provider_id(), &budget.model, - &class, status, &body, false, stop); + &class, status, &body, false, uncertain || vision); + if plugin_stop && !decision.hard_stop { + decision.action = crate::server::config::error_policy::ErrorAction::SwitchProvider; + if decision.scope == crate::server::config::error_policy::CooldownScope::Auto { + decision.scope = crate::server::config::error_policy::CooldownScope::Model; + } + } if let Some(reset) = header_reset { decision.reset_at = Some(decision.reset_at.unwrap_or(reset).max(reset)); } let mut error = error_policy::classified_error(&class, &body); error_policy::attach(&mut error, &decision); diff --git a/desktop-tauri/src-tauri/server/src/server/core/upstream/mod.rs b/desktop-tauri/src-tauri/server/src/server/core/upstream/mod.rs index 99837e3a9..7096c24bd 100644 --- a/desktop-tauri/src-tauri/server/src/server/core/upstream/mod.rs +++ b/desktop-tauri/src-tauri/server/src/server/core/upstream/mod.rs @@ -114,7 +114,11 @@ const INFLIGHT_WAIT_MS: u64 = 45_000; /// Node 版靠 `pickNextAccount` 返回 null 收尾 —— 每次轮换都会往 triedIds 里 /// 加一个账号,而账号上限是 20,所以必然收敛。这里额外加一个轮数上限兜底: /// 万一账号数据被手工改出「同一个 id 出现两次」之类的怪状,宁可报错也不要空转。 -pub(super) const MAX_ROUTE_ATTEMPTS: usize = 32; +/// +/// 取 100 而不是 32:`换账号上限` 允许配到 100(见 `config::MAX_SWITCHES`), +/// 硬闸若仍是 32,「配了 100 却只换 32 次」又变回同一个老问题。这里只防回环, +/// 真正的收敛条件仍是「队列里没有没试过的候选」。 +pub(super) const MAX_ROUTE_ATTEMPTS: usize = 100; /// 在途请求的完成信号(去重队列用)。 /// diff --git a/desktop-tauri/src-tauri/server/src/server/core/upstream/provider_loop.rs b/desktop-tauri/src-tauri/server/src/server/core/upstream/provider_loop.rs index 2453e1601..762481a27 100644 --- a/desktop-tauri/src-tauri/server/src/server/core/upstream/provider_loop.rs +++ b/desktop-tauri/src-tauri/server/src/server/core/upstream/provider_loop.rs @@ -445,9 +445,20 @@ pub(super) async fn forward_with_providers( ) -> Result { let model = model_of(ctx.body); if ctx.routing.group.is_some() { + // 路由组请求的初始占位快照:真正选到账号后会被 `target.decision` 覆盖, + // 但「一个都没选中就失败」时留下的就是这一份 —— 所以这里必须把成员级 + // blocked 全量(不是前 12 条)和按原因聚合一起带上,否则事后只能看到 + // 「都没有可用」却不知道是熔断、并发还是模型权限。 + let blocked: Vec<_> = ctx.routing.group_projection.blocked.iter().cloned().collect(); + let mut by_reason = serde_json::Map::new(); + for entry in &ctx.routing.group_projection.blocked { + let Some(state) = entry.get("state").and_then(Value::as_str) else { continue; }; + let count = by_reason.get(state).and_then(Value::as_u64).unwrap_or(0) + 1; + by_reason.insert(state.to_string(), Value::from(count)); + } ctx.telemetry.set_route_decision(json!({ "scope": ctx.routing.scope, "configSnapshot": ctx.routing.json(), "strategy": ctx.routing.settings.strategy.as_str(), "sticky": ctx.routing.settings.sticky.as_str(), - "ordered": [], "blocked": ctx.routing.group_projection.blocked.iter().take(12).collect::>(), + "ordered": [], "blocked": blocked, "blockedByReason": by_reason, "orderedTotal": ctx.routing.group_projection.accounts.len(), "blockedTotal": ctx.routing.group_projection.blocked.len() })); } // 候选家来自 `route_for_forward`(目录里没有这个模型名时会回落成默认 @@ -674,7 +685,20 @@ async fn attempt_queue( // 结果是「能换几个账号」根本没人管 —— 某家囤了 9 个账号时一次请求会一路 // 试到第 10 个,而用户填的那个数字要等跨家才生效。 let mut budget = RetryBudget::from_snapshot(ctx.error_policy.clone()); - let switch_total = ctx.error_policy.settings.switches as usize; + // ── 换号预算的**下限**是整条候选队列 ───────────────────────── + // 用户填的 `switches` 表达「最多换几次」,但它不能比候选队列还短: + // 队列里有 N 个没试过的候选时提前收尾,就是把「换一个本来能答上来的 + // 账号/提供商」变成「直接 400 给下游」。生产上的形状就是 21 个候选、 + // 默认 10 次预算 —— 试到第 10 个(全是同一家的工具预算 400)就收尾, + // 而排在第 12 位、不做工具模拟的那家其实一条就 200。 + // + // 所以取 `max(用户值, 队列规模)`,再受转发层的 `MAX_ROUTE_ATTEMPTS` + // 约束(那才是防死循环的硬闸)。 + let queue_cap = rotate::scoped_account_cap(service, provider_ids, cooldown_keys.request_model(), + ctx.pinned_account, Some(&ctx.routing)); + // 配成 0 是显式的「不换号」,尊重它;其余情况一律按队列规模兜底。 + let configured = ctx.error_policy.settings.switches as usize; + let switch_total = if configured == 0 { 0 } else { configured.max(queue_cap).min(MAX_ROUTE_ATTEMPTS) }; let mut switches_left = switch_total; let mut decision = ctx.telemetry.route_decision().unwrap_or_else(|| json!({})); decision["errorPolicyConfig"] = json!({ "revision": config::error_policy::revision(&ctx.error_policy), @@ -722,10 +746,20 @@ async fn attempt_queue( if ctx.telemetry.is_cancelled() { return Err(cancellation::cancelled_error()); } - let mut target = super::account_admission::select( + let mut target = match super::account_admission::select( service, provider_ids, &cooldown_keys, &tried_ids, ctx.pinned_account, &conv_key, &ctx.routing, connections, ctx.telemetry, - ).await?; + ).await { + Ok(target) => target, + Err(error) => { + // 选路阶段就收尾时,把决策快照交给 telemetry:请求日志的 route + // 才不会只剩一份占位快照(「谁可试 / 谁被什么挡住」全在这里)。 + if let Some(snapshot) = error.route_snapshot() { + ctx.telemetry.set_route_decision(snapshot.clone()); + } + return Err(error); + } + }; if let Some(override_proxy) = ctx.proxy_override { target.proxy = override_proxy.clone(); target.proxy_notice = None; @@ -785,7 +819,7 @@ async fn attempt_queue( return Ok(outcome); }, Err(error) => { - if ctx.telemetry.replay_guard().blocked() { return Err(error); } + if ctx.telemetry.replay_guard().blocked() && !reopen_after_rejection(ctx, &error) { return Err(error); } if super::vision_compat::handles_error(ctx, &error) { return Err(error); } // 手动终止优先(与无状态路径同一判定与理由):不把已受理的 // 终止当成「这一轮失败」去顺延下一个账号 @@ -798,10 +832,13 @@ async fn attempt_queue( } let mut error = error; if super::error_policy_finish::finish_failure(service, ctx, provider_ids, &cooldown_keys, - &failed_target, &mut error, &mut tried_ids, &mut switches_left, switch_total) { + &failed_target, &mut error, &mut tried_ids, &mut switches_left, switch_total, + &conv_key, &model, sticky_generation) { last_error = Some(error); continue 'accounts; } - return Err(error); + // 兜底也没能给出下一个:这时**不再把上游的 4xx 原样透给下游** + // —— 见 `exhausted_error`(换过 ≥2 个对象一律收成可重试的 503)。 + return Err(exhausted_error(Some(error), tried_ids.len())); } } @@ -871,10 +908,22 @@ async fn attempt_queue( return Ok(crate::server::core::plugin_host::hold_adapter(outcome, adapter_handle)); }, Err(error) => { - if ctx.telemetry.replay_guard().blocked() { return Err(error); } + if ctx.telemetry.replay_guard().blocked() && !reopen_after_rejection(ctx, &error) { return Err(error); } if super::vision_compat::handles_error(ctx, &error) { return Err(error); } - if matches!(error.code.as_deref(), Some("plugin_busy" | "gateway_busy" | "account_busy" | "plugin_resource_limit" - | "plugin_protocol_error" | "plugin_trap" | "plugin_response_started" | "web_tools_invalid_request")) { return Err(error); } + // ── 这一支以前「忙 / 插件协议错 / 插件崩了」一律直接抛回下游 ── + // 现在只有「响应字节已经在往客户端写」(`plugin_response_started`) + // 例外。实测(2026-11-21 21:34,`pro` 组):WorkBuddy 回 400 + // 「Illegal API invocation from an unapproved channel」,走的就是 + // 这张名单 → 直接 `return Err`,明细里那一轮的 `errorPolicy` 是 + // null(统一错误规则压根没跑)。结果请求在 4 次尝试后断在这家, + // 下游拿到 400 —— 而同一时刻 autoclaw / codearts / quwork 都能答 + // (紧随其后的那条请求就是 quwork 200 的)。 + // + // 忙(`plugin_busy` / `gateway_busy` / `account_busy`)、资源满 + // (`plugin_resource_limit`)、插件协议错 / 插件崩了(`plugin_trap`) + // 都属于「换一个候选仍可能有救」,交给下面的统一规则顺延: + // 顺延的前提是没救,而这几种恰恰是「这次没发成」而不是「这条请求死了」。 + if error.code.as_deref() == Some("plugin_response_started") { return Err(error); } let account_unavailable = matches!(error.code.as_deref(), Some("account_model_unavailable" | "account_model_permissions_unknown")); if ctx.images.is_some() && !account_unavailable { return Err(error); } @@ -895,10 +944,11 @@ async fn attempt_queue( } let mut error = error; if super::error_policy_finish::finish_failure(service, ctx, provider_ids, &cooldown_keys, - &failed_target, &mut error, &mut tried_ids, &mut switches_left, switch_total) { + &failed_target, &mut error, &mut tried_ids, &mut switches_left, switch_total, + &conv_key, &model, sticky_generation) { last_error = Some(error); continue 'accounts; } - return Err(error); + return Err(exhausted_error(Some(error), tried_ids.len())); } } @@ -1146,25 +1196,21 @@ async fn attempt_queue( // 个模型名在别几家都能答。换号顺延本来就不该只看「发出去之后 // 上游怎么回」:既然本地就判定不可用,队列里的下一家有机会。 // - // 其余构造期错误(400 缺模型名 / 转换失败、401 账号缺凭证、 - // 500 内部坏了)继续**直接终止**:那些是「这份请求本身坏了」, - // 换个账号发的是同一份坏请求,换满预算只会把一次 400 变成四条 - // 400,并把真实原因埋进顺延链里。 - let account_unavailable = error.code.as_deref().is_some_and(|code| { - matches!(code, "account_model_unavailable" | "account_model_permissions_unknown") - }); + // 其余构造期错误(网页工具字符预算超限这类 400、账号对模型无 + // 权限、转换失败)同样交给**统一错误规则**判定(#644):规则会 + // 区分「换一个账号仍可能好」(换号)、「同一家换账号也没用」(跳过 + // 这一家)与「再发一次可能重复执行」(硬终止)。在这里写死 + // `return Err` 等于绕过用户的整套错误处理设置。 if i32::from(readiness::LOCAL_PRECONDITION_STATUS) != error.status_code { - if account_unavailable || error.status_code == 501 { - let mut error = error; - if super::error_policy_finish::finish_failure(service, ctx, provider_ids, &cooldown_keys, - &target, &mut error, &mut tried_ids, &mut switches_left, switch_total) { - last_error = Some(error); continue 'accounts; - } - return Err(error); + let mut error = error; + if super::error_policy_finish::finish_failure(service, ctx, provider_ids, &cooldown_keys, + &target, &mut error, &mut tried_ids, &mut switches_left, switch_total, + &conv_key, &model, sticky_generation) { + last_error = Some(error); continue 'accounts; } - return Err(error); + return Err(exhausted_error(Some(error), tried_ids.len())); } - if ctx.telemetry.replay_guard().blocked() { return Err(error); } + if ctx.telemetry.replay_guard().blocked() && !reopen_after_rejection(ctx, &error) { return Err(error); } if defer_to_next_account( service, provider_ids, @@ -1206,7 +1252,7 @@ async fn attempt_queue( if !tried_ids.contains(&attempt_key) { tried_ids.push(attempt_key.clone()); } - if ctx.telemetry.replay_guard().blocked() { return Err(error); } + if ctx.telemetry.replay_guard().blocked() && !reopen_after_rejection(ctx, &error) { return Err(error); } if target.account_id.as_deref().is_some_and(|id| rotate::allows_route_skip(service, id)) && rotate::pick_next_account(service, provider_ids, &cooldown_keys, &tried_ids, ctx.pinned_account, &ctx.routing).is_some() @@ -1338,10 +1384,14 @@ async fn attempt_queue( // 时,粘的必须是现在这个能干活的。 let route_settings = ctx.routing.settings; if let Some(account_id) = target.account_id.as_deref() { - if route_settings.breaker_enabled { - service - .route - .breaker_success(account_id, route_settings.breaker_success_threshold); + // 熔断的「开关与阈值」以错误规则那份设置为准:失败计数在 + // `error_policy_finish` 里读的是 `error_policy.settings`, + // 成功恢复若还读 `routing.settings`,升级后两边一旦不同步, + // 失败计数就永远清零不了 —— 于是一个历史失败的账号每失败 + // 一次都被当成「刚攒够阈值」,反复熔断。 + let policy = &ctx.error_policy.settings; + if policy.breaker { + service.route.breaker_success(account_id, policy.breaker_successes as i64); } service.route.backoff_clear(account_id); service.route.sink_clear(account_id); @@ -1394,7 +1444,7 @@ async fn attempt_queue( break (response, wire_model, plan.response, antigravity_session); } Err(failure) => { - if ctx.telemetry.replay_guard().blocked() { + if ctx.telemetry.replay_guard().blocked() && !reopen_after_rejection(ctx, &failure.error) { ctx.telemetry.finish_last_attempt(Some(i64::from(failure.error.status_code)), Some(&failure.error.message)); return Err(failure.error); } @@ -1484,12 +1534,21 @@ async fn attempt_queue( service, provider_id, target.account_id.as_deref(), ).await { let delay = host_rule.retry_delay(0); - if !budget.take_retry(delay) { return Err(failure.error); } - ctx.telemetry.note_attempt_retry("登录凭证已刷新,在原账号重试一次", Some(401), delay); - super::error_policy_send::sleep_or_cancel(ctx.telemetry, delay).await; - session = fresh; - last_error = Some(failure.error); - continue; + // 等待预算用完只说明「这一刻不适合原地再等」,**不是**整条 + // 请求的结论:以前这里直接 `return Err`,用户看到的就是 + // 「401 之后什么都没换就抛出异常」。现在落下去走统一分类 + // (换号 / 换家),把剩下的候选试完。 + if budget.take_retry(delay) { + ctx.telemetry.note_attempt_retry("登录凭证已刷新,在原账号重试一次", Some(401), delay); + super::error_policy_send::sleep_or_cancel(ctx.telemetry, delay).await; + session = fresh; + last_error = Some(failure.error); + continue; + } + logging::console_line( + "[Upstream]", + &format!("账号 {account_id} 的凭证已刷新,但等待预算已用完,改为换号继续"), + ); } } else { // 刷新**失败**:这是「401 了、也试过续期、但没救回来」的 @@ -1556,13 +1615,16 @@ async fn attempt_queue( Some(i64::from(failure.error.status_code)), Some(&failure.error.message), ); - if ctx.telemetry.replay_guard().blocked() { return Err(failure.error); } + if ctx.telemetry.replay_guard().blocked() && !reopen_after_rejection(ctx, &failure.error) { + return Err(failure.error); + } let mut error = failure.error; if super::error_policy_finish::finish_failure(service, ctx, provider_ids, &cooldown_keys, - &target, &mut error, &mut tried_ids, &mut switches_left, switch_total) { + &target, &mut error, &mut tried_ids, &mut switches_left, switch_total, + &conv_key, &model, sticky_generation) { last_error = Some(error); continue 'accounts; } - return Err(error); + return Err(exhausted_error(Some(error), tried_ids.len())); } } @@ -1664,10 +1726,11 @@ async fn attempt_queue( super::error_policy::attach(&mut error, &decision); ctx.telemetry.finish_last_attempt(Some(i64::from(error.status_code)), Some(&error.message)); if super::error_policy_finish::finish_failure(service, ctx, provider_ids, &cooldown_keys, - &target, &mut error, &mut tried_ids, &mut switches_left, switch_total) { + &target, &mut error, &mut tried_ids, &mut switches_left, switch_total, + &conv_key, &model, sticky_generation) { last_error = Some(error); continue 'accounts; } - return Err(error); + return Err(exhausted_error(Some(error), tried_ids.len())); } Gate::Held(head) } else { @@ -1842,9 +1905,89 @@ async fn attempt_queue( } } } - Err(GatewayError::with_status(500, "上游转发重试次数超限")) + // ── 「换号轮转用完」:给下游一个**可重试**的答案,而不是一条 500 ────── + // 改造前这里恒返回 `500 上游转发重试次数超限`:客户端把它当服务器错误, + // 既不知道能不能重试,也看不到最后一次真实原因(排队里 43 个账号试到 + // 预算用尽,日志只剩这一句)。见 [`exhausted_error`]。 + Err(exhausted_error(last_error, tried_ids.len())) +} + +/// 换号 / 排队轮转走到尽头时的收尾错误。 +/// +/// 判据只有一条:**这条最终错误是否「等一会儿再试可能就好」**。 +/// +/// * 是(402 余额、408、425、429 限流/无套餐、5xx、以及并发排队超时的 +/// `account_busy`)→ 收成 **503 + `Retry-After`**,正文带上最后一次的上游 +/// 原文。理由:换号 / 排队已经试遍整个池子,这一轮确实没人能答;对下游来说 +/// 这属于「网关暂时没有承载者」,重发一次就有机会落到已经恢复的账号上。 +/// 保持上游的 429 反而更糟 —— 同一个模型名在下一分钟可能就由另一家答上来, +/// 而 429 让客户端以为「是它自己的额度问题」。 +/// * 否(400 参数 / 401 凭据 / 403 权限 / 404 模型不存在这类)→ **原样返回** —— +/// 但只在**这条请求只试过一个对象**时才原样:那才可能真的是「客户端请求本身 +/// 有问题」。一旦已经换过号 / 换过家(`tried >= 2`)还是同一个结论,就不能再 +/// 把它当客户端错误丢出去 —— 同一份 body 在两家都撞 400,最先该怀疑的是网关 +/// 侧的渠道 / 模型映射,把 400 透给下游只会让客户端以为「我的请求写错了」直接 +/// 中止(实测 WorkBuddy 那条 `Illegal API invocation from an unapproved +/// channel` 就是这样:上游渠道问题,客户端却收到 400)。这类收成 503 + +/// `Retry-After`,正文保留上游原文,客户端会按可重试处理。 +fn exhausted_error(last: Option, tried: usize) -> GatewayError { + let Some(error) = last else { + return GatewayError::with_status( + 503, "上游转发重试次数超限:这一轮没有任何候选账号应答,请稍后重试", + ) + .with_code("route_exhausted") + .with_retry_after_seconds(1); + }; + let retryable = matches!(error.status_code, 402 | 408 | 425 | 429 | 500 | 502 | 503 | 504) + || matches!(error.code.as_deref(), Some("account_busy" | "route_empty" | "route_exhausted")); + if !retryable && tried < 2 { + return error; + } + crate::server::logging::log_with_level( + "[Upstream]", + &format!( + "⚠️ 候选池本轮全部失败(最后一次 HTTP {} {}),按可重试的 503 route_exhausted 收尾", + error.status_code, error.message, + ), + "warn", + ); + GatewayError::with_status(503, format!( + "本轮候选账号都没答上来(最后一次:HTTP {} {});已进入冷却或排队的账号会自动恢复,请稍后重试", + error.status_code, error.message, + )) + .with_code("route_exhausted") + .with_reason("route_exhausted") + .with_retry_after_seconds(error.retry_after_secs.unwrap_or(1)) +} + +/// 上游**明确拒收**这一轮之后,解除请求级的「禁止重放」位,让队列继续(2026-11-21 加)。 +/// +/// ── 这是 WorkBuddy 那条 400 的真正卡点 ─────────────────────────────── +/// 插件家(`workbuddy` / `raccoon` / `loomy` 这类 WASM 对话)在**提交前**就会 +/// `freeze()` 请求级的 ReplayGuard(`wasm/conversation/workbuddy_http.rs`),把 +/// `blocked` 永久置 true。上游回 400 之后,本函数这些分支一进来就看到 +/// `blocked() == true` → `return Err(error)`,于是: +/// 队列里还有十几个可用候选一个都不试、`finish_failure` 根本没跑(明细里 +/// `errorPolicy` 是 null,日志里没有「错误结算」)、下游直接收到 400。 +/// +/// 判据刻意写死成「上游当场拒收」这一档:400 / 401 / 402 / 403 / 404 / 405 / +/// 406 / 409 / 410 / 413 / 415 / 422 / 429 / 501。这些状态说明请求**没有**进 +/// 上游执行队列,重放不会造成重复执行 / 重复计费;超时、5xx、无响应(0)不在此列 +/// —— 那些可能已经执行了,仍按「禁止重放」原样收尾。 +fn reopen_after_rejection(ctx: &ProviderContext<'_>, error: &crate::server::errors::GatewayError) -> bool { + if !ctx.telemetry.replay_guard().blocked() { return false; } + if ctx.telemetry.response_started() || ctx.telemetry.is_cancelled() { return false; } + if !matches!(error.status_code, 400 | 401 | 402 | 403 | 404 | 405 | 406 | 409 | 410 | 413 | 415 | 422 | 429 | 501) { + return false; + } + ctx.telemetry.replay_guard().confirm_not_sent(); + logging::log_with_level("[Upstream]", &format!( + "上游当场拒收(HTTP {} {}):这一轮没有执行,已解除「禁止重放」,继续顺延下一家", + error.status_code, error.message), "warn"); + true } + /// 门控后的 Chat 响应形态:`Live` = 未消费的 `Response`(原样直通); /// `Held` = 预读产物(用预读字节 + 剩余流重建,见 `upstream::refusal`)。 enum Gate { @@ -2081,7 +2224,8 @@ async fn attempt_custom( return Ok(outcome); } Err(mut error) => { - if ctx.telemetry.replay_guard().blocked() || ctx.telemetry.response_started() { + let blocked = ctx.telemetry.replay_guard().blocked(); + if (blocked && !reopen_after_rejection(ctx, &error)) || ctx.telemetry.response_started() { ctx.telemetry.finish_last_attempt(Some(i64::from(error.status_code)), Some(&error.message)); return Err(error); } diff --git a/desktop-tauri/src-tauri/server/src/server/core/upstream/replay_guard.rs b/desktop-tauri/src-tauri/server/src/server/core/upstream/replay_guard.rs index 49c1fdffd..ce72a837f 100644 --- a/desktop-tauri/src-tauri/server/src/server/core/upstream/replay_guard.rs +++ b/desktop-tauri/src-tauri/server/src/server/core/upstream/replay_guard.rs @@ -84,6 +84,30 @@ impl ReplayGuard { } } + /// 上游**明确拒绝**这一轮之后,解除「禁止重放」位,让同一份请求可以换下 + /// 一个候选继续(2026-11-21 加)。 + /// + /// ── 为什么这件事是安全的 ───────────────────────────────────── + /// `blocked` 的语义是「已经开了调用,不许再开第二次」,防的是**重复执行 / + /// 重复计费**。但 400 / 401 / 403 / 404 / 409 / 413 / 422 / 429 / 501 这一档 + /// 是上游**当场拒收**:请求根本没进执行队列,重放不会产生第二次执行。 + /// + /// 不解除的后果实测过(2026-11-21 23:43,`pro` 组):WorkBuddy 的插件在 + /// 提交前就 `freeze()` 了这个位(见 `wasm/conversation/workbuddy_http.rs`), + /// 随后上游回 400 `Illegal API invocation from an unapproved channel` —— + /// 请求在这一格 `return Err` 直接砸给下游,队列里另外 13 个可用候选一个都 + /// 没被试过,日志里连「错误结算」都没打出来。 + /// + /// 只由 upstream 在**确认这一轮没被执行**之后调用(判据见调用点), + /// 插件与托管任务层不得自己恢复权限。 + pub(super) fn confirm_not_sent(&self) { + if let Ok(mut state) = self.lock() { + if state.active_generation.is_none() { + state.blocked = false; + } + } + } + fn lock(&self) -> Result, ReplayError> { match self.state.lock() { Ok(state) => Ok(state), diff --git a/desktop-tauri/src-tauri/server/src/server/core/upstream/rotate.rs b/desktop-tauri/src-tauri/server/src/server/core/upstream/rotate.rs index c9aeabff3..1725913e7 100644 --- a/desktop-tauri/src-tauri/server/src/server/core/upstream/rotate.rs +++ b/desktop-tauri/src-tauri/server/src/server/core/upstream/rotate.rs @@ -314,7 +314,19 @@ fn select_target_account_sync( decision["scope"] = Value::String(request_routing.scope.clone()); decision["configSnapshot"] = request_routing.json(); if let Some(blocked) = decision.get_mut("blocked").and_then(Value::as_array_mut) { - blocked.extend(request_routing.group_projection.blocked.iter().take(12usize.saturating_sub(blocked.len())).cloned()); + // 路由组投影里被挡下的成员同样全量带上(理由见 `decision_json`): + // 「成员不可用原因」是「为什么要换家」的头号证据,截断后只剩前几条。 + blocked.extend(request_routing.group_projection.blocked.iter().take(DECISION_LIST_CAP).cloned()); + } + // 路由组投影(成员级:网关 Key 不允许 / 提供商不可用 / 生图模型 / 模型不在目录 / + // 该家没有可用账号)的拦截也并进同一条聚合 —— 排障时「为什么换家」与「为什么 + // 换号」是同一个问题的两面,分在两处看就又得靠人脑拼。 + if let Some(map) = decision.get_mut("blockedByReason").and_then(Value::as_object_mut) { + for entry in &request_routing.group_projection.blocked { + let Some(state) = entry.get("state").and_then(Value::as_str) else { continue }; + let count = map.get(state).and_then(Value::as_u64).unwrap_or(0) + 1; + map.insert(state.to_string(), Value::from(count)); + } } decision["blockedTotal"] = (plan.blocked.len() + request_routing.group_projection.blocked.len()).into(); if !conv_key.is_empty() { @@ -348,23 +360,28 @@ fn select_target_account_sync( .filter(|account| !matches!(account.get("enabled"), Some(Value::Bool(false)))) .count(); if !balance_blocked_ids.is_empty() && enabled_total > 0 { + logging::log_with_level("[Upstream]", &format!( + "⚠️ 路由内没有可转发账号:{} 个启用账号全部被限制器拦下(余额不足 / Token 周期额度到顶)", + balance_blocked_ids.len()), "warn"); return Err(GatewayError::with_status( 503, format!( "所有启用中的账号都被限制器拦下(已跳过 {} 个账号),无账号可转发:请检查余额读数与 Token 周期用量,或到账号设置的「限制器」里调整规则", balance_blocked_ids.len() ), - )); + ).with_route_snapshot(decision.clone())); } + logging::log_with_level("[Upstream]", + "⚠️ 路由内没有可转发账号:候选账号全部被禁用", "warn"); return Err(GatewayError::with_status( 503, "所有账号均已禁用,无账号可转发:请在账号页启用至少一个账号", - )); + ).with_route_snapshot(decision.clone())); } if super::account_admission::all_busy(&candidates, &counts, tried_ids) { return Err(GatewayError::with_status(503, "当前路由内的账号均已达到并发上限") - .with_code("account_busy")); + .with_code("account_busy").with_route_snapshot(decision.clone())); } if request_routing.strict_vision { @@ -379,6 +396,25 @@ fn select_target_account_sync( if pinned.is_none() { let earliest = enabled.iter().map(|account| routing::rate_limit_reset_at(account, keys, now)).filter(|at| *at > now).min(); if let Some(at) = earliest { + // ── 兜底:全队列都在冷却,但冷却未必是上游说的 ──────────── + // `routing_cooldown` 这条 429 是本请求「一个候选都没试就失败」的 + // 唯一来源,也是用户看到的「又是直接报错、没换号没换家」。 + // + // 冷却有两类来源:上游明确给了 `resetAt`(`guessed = false`)—— + // 它说「现在别来」,必须尊重,照旧回 429 让客户端等;另一类是我们 + // 自己按退避规则**估算**出来的时长(`guessed = true`),用它把整条 + // 请求判死属于「自己的记账把自己的活掐了」。所以这里只越过估算 + // 冷却:挑最早恢复的那个先试一次。成了就解开,不成也照常记一次 + // 失败(下一次估算会更长)。 + if let Some(account) = last_resort(&enabled, keys, tried_ids, now, &snap.open) { + let id = routing::account_id(&account).unwrap_or_default().to_string(); + if let Some(picked) = service.store.get_session_by_id(&id) { + logging::console_line("[Upstream]", &format!( + "候选全部处于冷却(最早 {} 恢复),按兜底尝试估算冷却中的账号 {id}", errors::format_reset_at_text(at))); + decision["lastResort"] = Value::Bool(true); + return Ok(with_proxy_notice(account, picked.proxy, picked.proxy_error, id, Some(decision))); + } + } return Err(GatewayError::with_status(429, format!("当前路由对象处于冷却期,最早 {} 恢复;未提前重发", errors::format_reset_at_text(at))) .with_code("routing_cooldown").with_retry_after_seconds(at.saturating_sub(now).max(0) as u64 / 1000 + 1)); } @@ -405,6 +441,7 @@ fn select_target_account_sync( best_effort = Some(account.clone()); } } + let mut no_session: Vec = Vec::new(); if let Some(account) = best_effort { if let Some(id) = routing::account_id(&account).map(str::to_string) { if let Some(entry) = service.store.get_session_by_id(&id) { @@ -416,22 +453,61 @@ fn select_target_account_sync( Some(decision), )); } + // 账号在库里但取不到会话 = 凭证缺失。以前这里静默跳过,最后让 + // 上层报一句「都没有可用凭证」,看不出是哪个账号、为什么。 + no_session.push(account_display(&account)); } } if request_routing.requires_account() { return Err(GatewayError::with_status(503, "当前生图账号均无可用凭证;未使用默认登录态或其他账号") - .with_code("image_account_unavailable")); + .with_code("image_account_unavailable").with_route_snapshot(decision.clone())); } if pinned.is_some() { return Err(GatewayError::with_status(401, "指定账号没有可用凭证;未回退到队首或默认登录态") - .with_code("account_scope_mismatch")); + .with_code("account_scope_mismatch").with_route_snapshot(decision.clone())); + } + // ── 收尾之前先排除「只是忙」这一种可能 ───────────────────── + // `all_busy` 会跳过本轮已被排除(`tried`)的账号,于是「所有有凭证的账号 + // 都只是被并发上限挤掉」时它会返回 false,请求一路掉到下面的收尾分支, + // 报出「没有可用凭证」这种与事实相反的话。这里按**不看 tried** 的口径再判 + // 一次:还有凭证的账号全在并发上限上就返回排队超时,让准入循环继续等。 + if super::account_admission::all_busy(&enabled, &counts, &[]) { + return Err(GatewayError::with_status(503, "当前路由内的账号均达到并发上限,正在排队等待槽位") + .with_code("account_busy").with_reason("account_busy").with_retry_after_seconds(1) + .with_route_snapshot(decision.clone())); } + // ── 收尾:这一轮一个都发不出去 ───────────────────────────── + // 以前这里固定写「当前模型路由中的账号都没有可用凭证」。触发它的原因其实 + // 有六种:模型权限不含该模型、账号没凭证、全在冷却 / 熔断、并发全满、 + // 本轮已全部试过、候选被限制器拦下。文案必须按 `plan.blocked` 的真实原因 + // 拼出来,否则用户只能看到一句与事实不符的「没有凭证」。 + let reasons = summarize_blocked(&plan); + let reason_text = if reasons.is_empty() { + "候选账号都被本轮尝试排除或并发占满".to_string() + } else { + reasons.join(";") + }; + let tried_note = if tried_ids.is_empty() { + String::new() + } else { + format!(",本轮已试 {} 个", tried_ids.len()) + }; + let session_note = if no_session.is_empty() { + String::new() + } else { + format!(";{} 取不到可用会话(凭证缺失)", no_session.join("、")) + }; + logging::log_with_level("[Upstream]", &format!( + "⚠️ 路由内没有可转发的账号:候选 {} 个{},原因:{}{}", + enabled.len(), tried_note, reason_text, session_note), "warn"); + let message = format!( + "当前路由内没有可转发的账号:{}{}(候选 {} 个{})。请在路由页检查账号的模型权限、凭证与冷却状态", + reason_text, session_note, enabled.len(), tried_note); if request_routing.profile.is_some() { - return Err(GatewayError::with_status( - 503, "当前模型路由中的账号都没有可用凭证,请在路由页检查账号状态", - )); + return Err(GatewayError::with_status(503, message) + .with_code("route_empty").with_route_snapshot(decision.clone())); } decision["picked"] = Value::String(String::new()); Ok(RouteTarget { @@ -445,6 +521,24 @@ fn select_target_account_sync( }) } +/// 把 `plan.blocked`(以及排在队尾等槽位的「并发已满」)聚成一句可读文本。 +/// +/// 只用于收尾时的用户文案与日志:**每个状态取第一条原因的原话**,计数按状态。 +/// 这样「全在冷却」「全没有该模型」「并发全满」在提示里能直接区分开,不必再让 +/// 人翻库猜。 +fn summarize_blocked(plan: &routing::RoutePlan) -> Vec { + let mut counts: std::collections::BTreeMap<&'static str, (usize, String)> = Default::default(); + let queued = plan.ordered.iter().filter(|entry| entry.state != "usable"); + for entry in plan.blocked.iter().chain(queued) { + let slot = counts.entry(entry.state).or_insert_with(|| (0, entry.reason.clone())); + slot.0 += 1; + } + counts + .into_iter() + .map(|(state, (count, reason))| format!("{}({} 个,state={})", reason, count, state)) + .collect() +} + /// 账号记录上的 provider id(缺失按默认 provider)。 /// 实现与出处都在 `routing` —— 那里也要按 provider 收窄候选(`pick_for_model`), /// 一处实现两处用,免得「缺失回落默认家」这条规则被抄成两份、日后改歪一份。 @@ -502,12 +596,7 @@ pub(super) fn scoped_accounts( pinned: Option<&str>, request_routing: Option<&super::route_context::RequestRouting>, ) -> Vec { - let accounts = accounts_in_providers(service, providers, pinned); - let accounts = if pinned.is_some() && !request_routing.is_some_and(|routing| routing.strict_vision) { accounts } else if let Some(request_routing) = request_routing { - request_routing.accounts(accounts) - } else { - crate::server::core::routing_scope::apply_accounts(&accounts, model) - }; + let accounts = scoped_in_providers(service, providers, model, pinned, request_routing); let keys = routing::CooldownKeys::new(model); let accounts: Vec = accounts.into_iter().map(|mut account| { let provider = provider_of(&account).to_string(); @@ -525,6 +614,41 @@ pub(super) fn scoped_accounts( if routable.is_empty() { accounts } else { routable } } +/// 候选账号的**作用域过滤**(路由组 / 指定账号 / 路由作用范围),不含冷却判定。 +fn scoped_in_providers( + service: &UpstreamService, + providers: &[&str], + model: &str, + pinned: Option<&str>, + request_routing: Option<&super::route_context::RequestRouting>, +) -> Vec { + let accounts = accounts_in_providers(service, providers, pinned); + if pinned.is_some() && !request_routing.is_some_and(|routing| routing.strict_vision) { + accounts + } else if let Some(request_routing) = request_routing { + request_routing.accounts(accounts) + } else { + crate::server::core::routing_scope::apply_accounts(&accounts, model) + } +} + +/// 这条请求的候选池**规模**(不含冷却 / 限额 / 熔断判定)。 +/// +/// 用途只有一个:给「最多换几个账号」定一条**下限**。队列里有多少候选, +/// 这条请求至少就该换几次 —— 否则一条 10 个候选的队列配上默认 5 次的预算, +/// 就会出现「第 6 个候选本来能答上来,却因为预算用完直接 400 给下游」。 +/// 这里刻意不逐账号查冷却(那是 `scoped_accounts` 的活):拿到的是上界, +/// 宁可多给几个额度(真失败时队列自己会把名额用光),也不要提前截断。 +pub(super) fn scoped_account_cap( + service: &UpstreamService, + providers: &[&str], + model: &str, + pinned: Option<&str>, + request_routing: Option<&super::route_context::RequestRouting>, +) -> usize { + scoped_in_providers(service, providers, model, pinned, request_routing).len() +} + /// 组装选路结果;代理解析失败时把提示**带进选路结果**(本次回退直连)。 /// /// ── 提示为什么是返回值的一部分而不是当场打日志 ──────────────── @@ -720,8 +844,15 @@ pub(super) fn allows_route_skip(service: &UpstreamService, account_id: &str) -> /// `keys` 见 [`select_target_account`]:冷却按各家真名判定。 /// 排序走与第一级选路**同一个** `routing::plan_route`(同一策略、同一份运行期 /// 状态快照,只是不做粘性查找、不前进轮转游标)—— 429 降级 / 失败顺延接的 -/// 「下一个」与队列面板画的顺序因此一致;并发上限的过滤由此自动获得, -/// 换号顺延不会把请求塞回一个已达上限的账号。 +/// 「下一个」与队列面板画的顺序因此一致。 +/// +/// ── 并发满的账号现在也在「下一个」里(2026-11-21 改)────────────── +/// 改造前 `plan_route` 把「并发已满」与「禁用 / 冷却 / 余额不足」同等剔掉,于是 +/// 某家三个账号同时有在途请求时整家从顺延链里消失:一次 `pro` 组请求 56 个候选 +/// 跳过 55 个,唯一剩下的那个没套餐,撞 429 之后这里返回 `None` ⇒ 客户端直接 +/// 收到 429「没有下一家」。现在忙账号排在可用账号之后的**队尾**,会被当成 +/// 「下一个」返回,由发送前的并发预占(`account_admission`)原地等槽位。 +/// 「不会塞回已达上限的账号」这条仍然成立:预占失败就不发,只是**等**而不是**跳**。 /// /// `pinned` 见 [`select_target_account`]:钉住账号时,候选池里只有那一个账号、 /// 它已经在 `tried_ids` 里 —— 本函数因此必然返回 None,也就是「不顺延」。 @@ -759,13 +890,84 @@ pub(super) fn pick_next_account( sticky_account: None, }; let plan = routing::plan_route(&candidates, keys, &counts, tried_ids, now, &meta); - plan.ordered.into_iter().next().map(|entry| entry.account) + if let Some(entry) = plan.ordered.into_iter().next() { + return Some(entry.account); + } + // 队列被冷却 / 并发 / 退避挡得一个不剩 —— 顺延路径同样不能就此收尾: + // 与首轮选路共用 `last_resort` 的口径(只越过我们自己的估算冷却)。 + last_resort(&candidates, keys, tried_ids, now, &snap.open) +} + +/// 账号此刻的冷却如果**全是我们自己估算**的,返回最晚的恢复时间。 +/// +/// 任何一个上游明确声明过的冷却(`guessed != true`)都直接返回 `None` —— +/// 那是上游在说「现在别来」,兜底不得越过它。 +fn guessed_reset(account: &Value, wire: &str, now: i64) -> Option { + let mut entries: Vec<&Value> = Vec::new(); + if let Some(entry) = account.get("rateLimits").and_then(|limits| limits.get(wire)) { + entries.push(entry); + } + if let Some(entry) = account.get("routingCooldowns").and_then(|limits| limits.get("@account")) { + entries.push(entry); + } + if let Some(entry) = account.get("providerCooldown") { + entries.push(entry); + } + let mut latest = 0i64; + for entry in entries { + let Some(at) = entry["resetAt"].as_i64().filter(|at| *at > now) else { continue }; + if entry["guessed"].as_bool() != Some(true) { + return None; + } + latest = latest.max(at); + } + (latest > 0).then_some(latest) +} + +/// 全队列被冷却挡住时的兜底候选:估算冷却中、最早恢复、本请求还没试过的那个。 +/// +/// 只看估算冷却(见 [`guessed_reset`]),所以「上游明确让我们等」的队列不会 +/// 被这条兜底绕过;**熔断中的账号也不碰** —— 熔断的含义就是「先别用它」,兜底 +/// 越过它等于把熔断作废。反复失败时估算会一次比一次长,不会把同一个账号 +/// 无休止地重试(且每次都会进 `tried_ids`)。 +fn last_resort( + accounts: &[Value], + keys: &routing::CooldownKeys<'_>, + tried_ids: &[String], + now: i64, + open: &std::collections::HashSet, +) -> Option { + accounts + .iter() + .filter(|account| { + if matches!(account.get("enabled"), Some(Value::Bool(false))) { + return false; + } + if routing::account_id(account).is_some_and(|id| open.contains(id)) { + return false; + } + let key = crate::server::core::routing_groups::attempt_key(account); + !key.is_empty() && !tried_ids.iter().any(|tried| tried == &key) + }) + .filter_map(|account| { + guessed_reset(account, &keys.for_account(account), now).map(|at| (at, account)) + }) + .min_by_key(|(at, account)| (*at, account.get("priority").and_then(Value::as_i64).unwrap_or(i64::MAX))) + .map(|(_, account)| Value::clone(account)) } /// 选路决策快照(请求日志「路由回放」的数据源)。 /// -/// 有界:排序清单与被跳过者各最多带 12 条 —— 账号几十个时全部带上只会 -/// 让每条请求日志膨胀,而前 12 位已足以回答「为什么是它、为什么不是那个」。 +/// ── 为什么不再截断到 12 条(2026-11-21 修正)───────────────────── +/// 改造前这里的排序清单与被跳过者各 `take(12)`,`blockedTotal` 只给一个数。 +/// 现实里的队列是这个量级:`pro` 组 14 个成员、43 个账号、56 个候选, +/// 一次请求里 55 个被跳过 —— 12 条窗口永远只露出同一批「便宜账号」 +/// (workbuddy / catpaw / trae / raccoon),剩下 43 条为什么被跳过一个字都没留。 +/// 排障时看到的就是「池子莫名其妙全不可用」,却查不出哪几家被谁拦了。 +/// +/// 现在改成**全量落库**,并额外给一份 `blockedByReason`(状态 → 个数)聚合: +/// 前者回答「具体谁被跳过」,后者一眼能看出「55 个里 40 个是冷却、10 个是忙」。 +/// 上限只留一个防爆的硬顶([`DECISION_LIST_CAP`]),正常队列碰不到。 fn decision_json( plan: &routing::RoutePlan, settings: &config::RoutingSettings, @@ -784,18 +986,27 @@ fn decision_json( "reason": entry.reason, }) }; + let mut by_reason: std::collections::BTreeMap<&'static str, usize> = Default::default(); + for entry in &plan.blocked { + *by_reason.entry(entry.state).or_insert(0) += 1; + } json!({ "strategy": settings.strategy.as_str(), "sticky": settings.sticky.as_str(), "stickyHit": plan.sticky_hit, "picked": plan.ordered.first().map(|entry| entry.id.clone()).unwrap_or_default(), - "ordered": plan.ordered.iter().take(12).map(entry_json).collect::>(), - "blocked": plan.blocked.iter().take(12).map(entry_json).collect::>(), + "ordered": plan.ordered.iter().take(DECISION_LIST_CAP).map(entry_json).collect::>(), + "blocked": plan.blocked.iter().take(DECISION_LIST_CAP).map(entry_json).collect::>(), + "blockedByReason": by_reason, + "queuedTotal": plan.ordered.iter().filter(|entry| entry.state == "concurrency").count(), "orderedTotal": plan.ordered.len(), "blockedTotal": plan.blocked.len(), }) } +/// 决策快照里每份清单的硬顶(防爆,正常队列几十个成员碰不到)。 +const DECISION_LIST_CAP: usize = 200; + /// 限制器软跳过的候选剔除:**余额不足**(限制器余额 skip 规则命中:最近读数 /// 低于阈值)或 **Token 限额**(Token skip 规则命中:当前重置窗口内消耗已达 /// 阈值)的账号在进选路**之前**整体拿掉 —— 三级选择(正常选路 / 兜底等恢复 / diff --git a/desktop-tauri/src-tauri/server/src/server/core/upstream/route_state.rs b/desktop-tauri/src-tauri/server/src/server/core/upstream/route_state.rs index a2af2719a..0a84cc34d 100644 --- a/desktop-tauri/src-tauri/server/src/server/core/upstream/route_state.rs +++ b/desktop-tauri/src-tauri/server/src/server/core/upstream/route_state.rs @@ -335,6 +335,11 @@ impl RouteState { self.sticky.bind(key, model, account_id, source, now, ttl_ms, generation); } + /// 失败时解除该会话对某个候选的绑定(见 `StickySessions::forget`)。 + pub(super) fn sticky_forget(&self, key: &str, model: &str, candidate: &str, generation: u64) { + self.sticky.forget(key, model, candidate, generation); + } + pub(super) fn sticky_list(&self, model: Option<&str>, now: i64) -> Vec { let (profiles, base) = crate::server::config::routing_snapshot(); self.sticky.list(model, now, |name| profiles.settings_for(name, base).sticky.ttl_ms().unwrap_or(0)) diff --git a/desktop-tauri/src-tauri/server/src/server/core/upstream/route_sticky.rs b/desktop-tauri/src-tauri/server/src/server/core/upstream/route_sticky.rs index 0d762c5bd..5f02dd363 100644 --- a/desktop-tauri/src-tauri/server/src/server/core/upstream/route_sticky.rs +++ b/desktop-tauri/src-tauri/server/src/server/core/upstream/route_sticky.rs @@ -109,6 +109,21 @@ impl StickySessions { })).collect() } + /// 某个候选失败后解除该会话的绑定(仅当绑定的正是这个候选)。 + /// + /// 粘性只在成功时建立;失败不解除的后果是「同一会话的下一条请求仍然先撞 + /// 同一个失败账号」—— 429 时表现为「这个会话每次先吃一个 429」。 + /// `generation` 与 `bind` 同款守卫:期间有人手动清空过,就不动新状态。 + pub(super) fn forget(&self, key: &str, model: &str, candidate: &str, generation: u64) { + if key.is_empty() || candidate.is_empty() { return; } + let Ok(mut table) = self.table.lock() else { return }; + if table.generation != generation { return; } + let id = entry_id(key, model); + if table.entries.get(&id).is_some_and(|entry| entry.account_id == candidate) { + table.entries.remove(&id); + } + } + pub(super) fn clear(&self, id: Option<&str>, model: Option<&str>) -> usize { let Ok(mut table) = self.table.lock() else { return 0 }; let before = table.entries.len(); diff --git a/desktop-tauri/src-tauri/server/src/server/core/usage_records.rs b/desktop-tauri/src-tauri/server/src/server/core/usage_records.rs index 925283aec..70112ed6f 100644 --- a/desktop-tauri/src-tauri/server/src/server/core/usage_records.rs +++ b/desktop-tauri/src-tauri/server/src/server/core/usage_records.rs @@ -188,6 +188,37 @@ pub fn balance_facts() -> HashMap { // ─── 写 ────────────────────────────────────────────────────── +/// 上游明确说「余额/积分不足」时,把账号余额读数**按 0 落一次**。 +/// +/// 为什么不信本地的余额查询:积分靠上游接口读,字段形状一变、或者把「钱包」 +/// 当成积分池,就会读出一个明显偏高的数字。限制器和低余额跳过都按这个数字 +/// 判断,于是账号一直显得「有钱」——每条请求都被派上去,再稳定吃一次 402 +/// `积分余额不足`。上游的 402 是比本地读数**更权威的事实**:这里把它直接落成 +/// 0,余额列跟着显示 0、低余额规则立刻拦下它,等下一次成功查询(或用户充值 +/// 后重新读到真余额)再自动恢复 —— 不需要人去手动改数。 +/// +/// 只覆盖余额(`totalLeft` / `available`),不动 `query_config` 与查询配置, +/// 所以下一次查询照常进行,读数一旦对得上就把 0 顶掉。 +pub fn force_zero_balance(account_id: &str, reason: &str) { + if account_id.is_empty() { return; } + let current = load(account_id); + let unit = current.usage.as_ref().and_then(|usage| usage.get("unit")).and_then(Value::as_str) + .filter(|unit| !unit.is_empty()).unwrap_or("积分"); + let usage = serde_json::json!({ + "unit": unit, + "available": 0.0, + "remaining": 0.0, + "totalLeft": 0.0, + "note": reason, + "forcedZeroAt": logging::now_ms(), + }); + let outcome = UsageOutcome { usage: Some(usage), error: None, code: None, diagnostics: None }; + // 失败不当错误:写不进去只是这次没落上 0,冷却与熔断仍然照常生效。 + if !write_result(account_id, &outcome, ¤t.query_config, "upstream-balance-zero") { + logging::verbose("[Usage]", &format!("账号 {account_id} 的余额按 0 落库失败(上游已报余额不足)")); + } +} + /// 记一笔「尝试开始」(心跳路径在**发请求之前**调用,见模块头)。 /// 只推进时间戳,不动上一次的结果 —— 查询还没回来,旧读数仍是最新事实。 pub fn mark_attempt(account_id: &str) { diff --git a/desktop-tauri/src-tauri/server/src/server/errors.rs b/desktop-tauri/src-tauri/server/src/server/errors.rs index 5097e57d2..869ab106b 100644 --- a/desktop-tauri/src-tauri/server/src/server/errors.rs +++ b/desktop-tauri/src-tauri/server/src/server/errors.rs @@ -55,6 +55,11 @@ pub struct GatewayError { pub(crate) native_response: Option<(crate::server::core::protocol::native::WireProtocol, Value, axum::http::HeaderMap)>, /// 只随受保护的登录任务返回,不进入模型 API 的错误响应。 pub(crate) login_diagnostic: Option, + /// 选路阶段的决策快照(`ordered` / `queued` / `blocked` / `blockedByReason`)。 + /// 「一个账号都没试就失败」的错误由这里带上现场:请求日志里的 route + /// 原本只有选路成功时才写,提前收尾时只剩一份占位快照,看不到到底 + /// 是「全在冷却」「全没凭证」还是「都被并发占满」。 + pub(crate) route_snapshot: Option, } #[derive(Clone, Debug)] @@ -80,6 +85,7 @@ impl GatewayError { routing_error: None, native_response: None, login_diagnostic: None, + route_snapshot: None, } } @@ -97,6 +103,7 @@ impl GatewayError { routing_error: None, native_response: None, login_diagnostic: None, + route_snapshot: None, } } @@ -111,6 +118,18 @@ impl GatewayError { self } + /// 挂上选路阶段的决策快照(`ordered` / `queued` / `blocked` / `blockedByReason`)。 + /// 让「一个账号都没试就收尾」的失败也能在请求日志里留下完整现场。 + pub fn with_route_snapshot(mut self, snapshot: Value) -> Self { + self.route_snapshot = Some(snapshot); + self + } + + /// 取出挂着的决策快照(转发层据此写进请求日志的 `route`)。 + pub fn route_snapshot(&self) -> Option<&Value> { + self.route_snapshot.as_ref() + } + /// 挂上可区分的拒绝原因(目前仅容量/并发拒绝等路径使用) pub fn with_reason(mut self, reason: impl Into) -> Self { self.reason = Some(reason.into()); diff --git a/desktop-tauri/src-tauri/server/src/server/http.rs b/desktop-tauri/src-tauri/server/src/server/http.rs index ad64c791d..d95a90155 100644 --- a/desktop-tauri/src-tauri/server/src/server/http.rs +++ b/desktop-tauri/src-tauri/server/src/server/http.rs @@ -1223,6 +1223,9 @@ fn attach_cors(headers: &mut axum::http::HeaderMap) { /// `/v1/models` 是独立的只读探针:不带 Key 可读取,携带 Key 时必须有效。 async fn require_api_key(mut request: Request, next: Next) -> Response { let path = request.uri().path().to_string(); + // 面包屑:面板/客户端的**每个**请求都在这里过一遍。启动后崩溃时, + // 最后一行能直接告诉我们「是后台维护还是某个接口」,不用再猜。 + crate::server::logging::stage(format!("请求 {} {path}", request.method())); if path.starts_with("/v1/") { let access = match api::model_access::authenticate(request.headers(), "") { Ok(access) => access, diff --git a/desktop-tauri/src-tauri/server/src/server/logging.rs b/desktop-tauri/src-tauri/server/src/server/logging.rs index ac28cbd02..a93a4a950 100644 --- a/desktop-tauri/src-tauri/server/src/server/logging.rs +++ b/desktop-tauri/src-tauri/server/src/server/logging.rs @@ -222,6 +222,34 @@ pub fn console_line(tag: &str, text: &str) { write_file_line(&line); } +/// 阶段面包屑:只在 `AGENT2API_TRACE_STAGES=1` 时输出 `[Stage] …` 一行。 +/// +/// 为什么需要它:Windows 上的栈溢出走 SEH,`0xC00000FD` 直接终止进程, +/// **不会**打印调用栈(`RUST_BACKTRACE` 也拿不到帧)。进程死前留下的唯一线索 +/// 就是控制台最后一行,于是把「现在走到哪一步」显式打出来 —— 复现一次就能 +/// 指着最后一条 `[Stage]` 说「死在这一步」,不用再靠猜。 +/// +/// 只写控制台、不入库:一次启动会打出几十行,属于排障期的一次性输出, +/// 不该污染日志页。 +pub fn stage(text: impl AsRef) { + static ENABLED: OnceLock = OnceLock::new(); + let enabled = *ENABLED.get_or_init(|| { + // **debug 构建默认打开**:栈溢出是「进程说死就死」,逼着人先设环境变量 + // 再复现一次,等于多一轮 8 分钟编译。排障期宁可吵一点。 + // release 构建仍默认关闭(正式分发不带这些行)。 + // 显式 `AGENT2API_TRACE_STAGES=0` 可在 debug 下静音。 + let raw = std::env::var("AGENT2API_TRACE_STAGES").ok(); + match raw.as_deref().map(str::trim) { + Some("0" | "false" | "FALSE" | "no") => false, + Some("1" | "true" | "TRUE" | "yes") => true, + _ => cfg!(debug_assertions), + } + }); + if enabled { + console_line("[Stage]", text.as_ref()); + } +} + /// 双通道日志(对应 Node 版 log())。 /// /// 入库前会做与 Node 版相同的处理:把各段参数用空格连接后 trim, diff --git a/desktop-tauri/ui-islands/src/islands/routing-types.ts b/desktop-tauri/ui-islands/src/islands/routing-types.ts index 64c9971a6..66c00fa5d 100644 --- a/desktop-tauri/ui-islands/src/islands/routing-types.ts +++ b/desktop-tauri/ui-islands/src/islands/routing-types.ts @@ -48,6 +48,10 @@ export type RouteDecision = { configSnapshot?: { groupId?: string; groupName?: string; members?: Array & { accountCount: number }>; capturedAt: number; scope: string; strategy: string; sticky: string; providerScope?: RouteProviderScope; accountCount?: number; providerCount?: number } orderedTotal?: number blockedTotal?: number + /** ordered 里「并发已满、排队等槽位」的个数(状态仍是 concurrency) */ + queuedTotal?: number + /** 被跳过者按原因聚合(state → 个数):先看这一眼,再展开看具体是谁 */ + blockedByReason?: Record ordered?: RouteEntry[] blocked?: RouteEntry[] } diff --git a/desktop-tauri/ui-islands/src/islands/settings-model.ts b/desktop-tauri/ui-islands/src/islands/settings-model.ts index 68a7b68fe..2200ad275 100644 --- a/desktop-tauri/ui-islands/src/islands/settings-model.ts +++ b/desktop-tauri/ui-islands/src/islands/settings-model.ts @@ -641,8 +641,8 @@ export const RETRY_FIELDS: NumberField[] = [ label: t('切换账号重试次数'), unit: t('次'), min: 0, - max: 10, - hint: t('失败后最多再换几个账号试(填 N = 最多换 N 个,首发那个不算)。换到同一家名下另一个账号、或换到另一家,都各算一次;换满仍失败就返回错误。可填 0–10,0 表示失败立即报错。'), + max: 100, + hint: t('失败后最多再换几个账号试(填 N = 最多换 N 个,首发那个不算)。换到同一家名下另一个账号、或换到另一家,都各算一次;换满仍失败就返回错误。可填 0–100,0 表示失败立即报错。'), }, { key: 'retryIntervalSeconds', diff --git a/desktop-tauri/ui-shared/routing-errors-panel.tsx b/desktop-tauri/ui-shared/routing-errors-panel.tsx index 17f13c45b..89f29d10f 100644 --- a/desktop-tauri/ui-shared/routing-errors-panel.tsx +++ b/desktop-tauri/ui-shared/routing-errors-panel.tsx @@ -85,7 +85,7 @@ export function RoutingErrorsPanel({ api, t, active = true, identity = '', reloa }}>{t('恢复建议值')}
patch({ resends })} /> - patch({ switches })} /> + patch({ switches })} /> patch({ intervalSeconds })} /> patch({ waitBudgetSeconds })} />
}> diff --git a/desktop-tauri/ui-shared/routing-errors-preview.tsx b/desktop-tauri/ui-shared/routing-errors-preview.tsx index d577bdb81..1c3c3d0c4 100644 --- a/desktop-tauri/ui-shared/routing-errors-preview.tsx +++ b/desktop-tauri/ui-shared/routing-errors-preview.tsx @@ -24,7 +24,7 @@ export function ErrorPreviewPanel({ settings, providers, t, input, onChange }: { ({ value: item.id, label: item.label }))} onChange={provider => patch({ provider })} /> patch({ model })} /> patch({ pinned })} /> -
patch({ switchesUsed })} /> +
patch({ switchesUsed })} /> patch({ resendsUsed })} /> patch({ strikes })} />
diff --git a/desktop-tauri/ui-shared/routing-errors-types.ts b/desktop-tauri/ui-shared/routing-errors-types.ts index 614af4d22..c903609d8 100644 --- a/desktop-tauri/ui-shared/routing-errors-types.ts +++ b/desktop-tauri/ui-shared/routing-errors-types.ts @@ -50,7 +50,7 @@ export function cooldownSummary(rule: ErrorRule, settings: ErrorSettings, t: Err } export function errorPolicyValidation(settings: ErrorSettings, t: ErrorTranslate): string | null { const fields: [number, number, number, string][] = [ - [settings.resends, 0, 10, t('原账号重发')], [settings.switches, 0, 10, t('最多再换账号')], + [settings.resends, 0, 10, t('原账号重发')], [settings.switches, 0, 100, t('最多再换账号')], [settings.intervalSeconds, 0, 300, t('重发间隔')], [settings.waitBudgetSeconds, 0, 300, t('累计等待上限')], [settings.cooldownFloorSeconds, 1, 60, t('最短限流冷却')], [settings.backoffSeconds, 1, 3600, t('首次休息时间')], [settings.backoffCapSeconds, settings.backoffSeconds, 3600, t('连续失败最长休息')], [settings.sinkSeconds, 30, 3600, t('最长保留时间')],