@xixka/dsh-hub 0.2.9 → 0.3.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +2 -0
- package/lib/account-pool.d.ts +34 -3
- package/lib/account-pool.d.ts.map +1 -1
- package/lib/account-pool.js +61 -9
- package/lib/account-pool.js.map +1 -1
- package/lib/aggregate-adapter.d.ts.map +1 -1
- package/lib/aggregate-adapter.js +17 -6
- package/lib/aggregate-adapter.js.map +1 -1
- package/lib/badge-subscription.d.ts.map +1 -1
- package/lib/badge-subscription.js +5 -0
- package/lib/badge-subscription.js.map +1 -1
- package/lib/baizhi-credits.d.ts +21 -1
- package/lib/baizhi-credits.d.ts.map +1 -1
- package/lib/baizhi-credits.js +111 -8
- package/lib/baizhi-credits.js.map +1 -1
- package/lib/buddy-balance-selector.d.ts +17 -1
- package/lib/buddy-balance-selector.d.ts.map +1 -1
- package/lib/buddy-balance-selector.js +84 -4
- package/lib/buddy-balance-selector.js.map +1 -1
- package/lib/client/jet-hub.js +29 -29
- package/lib/cline-adapter.d.ts.map +1 -1
- package/lib/cline-adapter.js +9 -1
- package/lib/cline-adapter.js.map +1 -1
- package/lib/codearts-vision.d.ts +23 -15
- package/lib/codearts-vision.d.ts.map +1 -1
- package/lib/codearts-vision.js +29 -16
- package/lib/codearts-vision.js.map +1 -1
- package/lib/credential-resolver.d.ts +11 -0
- package/lib/credential-resolver.d.ts.map +1 -1
- package/lib/credential-resolver.js +1 -0
- package/lib/credential-resolver.js.map +1 -1
- package/lib/credits.d.ts +17 -0
- package/lib/credits.d.ts.map +1 -1
- package/lib/credits.js.map +1 -1
- package/lib/gemini-adapter.d.ts.map +1 -1
- package/lib/gemini-adapter.js +7 -1
- package/lib/gemini-adapter.js.map +1 -1
- package/lib/index.d.ts.map +1 -1
- package/lib/index.js +94 -2
- package/lib/index.js.map +1 -1
- package/lib/jet-hub-rpc.d.ts +86 -12
- package/lib/jet-hub-rpc.d.ts.map +1 -1
- package/lib/jet-hub-rpc.js +575 -116
- package/lib/jet-hub-rpc.js.map +1 -1
- package/lib/jet-hub-store.d.ts +8 -1
- package/lib/jet-hub-store.d.ts.map +1 -1
- package/lib/jet-hub-store.js +32 -4
- package/lib/jet-hub-store.js.map +1 -1
- package/lib/leveldb-sstable.d.ts +167 -0
- package/lib/leveldb-sstable.d.ts.map +1 -0
- package/lib/leveldb-sstable.js +472 -0
- package/lib/leveldb-sstable.js.map +1 -0
- package/lib/llm-adapter.d.ts +78 -0
- package/lib/llm-adapter.d.ts.map +1 -1
- package/lib/llm-adapter.js +208 -49
- package/lib/llm-adapter.js.map +1 -1
- package/lib/loomy-adapter.d.ts +28 -0
- package/lib/loomy-adapter.d.ts.map +1 -1
- package/lib/loomy-adapter.js +119 -19
- package/lib/loomy-adapter.js.map +1 -1
- package/lib/loomy-product.d.ts +84 -3
- package/lib/loomy-product.d.ts.map +1 -1
- package/lib/loomy-product.js +43 -6
- package/lib/loomy-product.js.map +1 -1
- package/lib/magicrew-adapter.d.ts.map +1 -1
- package/lib/magicrew-adapter.js +3 -0
- package/lib/magicrew-adapter.js.map +1 -1
- package/lib/magicrew-auth.d.ts +12 -0
- package/lib/magicrew-auth.d.ts.map +1 -1
- package/lib/magicrew-auth.js +36 -2
- package/lib/magicrew-auth.js.map +1 -1
- package/lib/magicrew-browser-login.d.ts +51 -0
- package/lib/magicrew-browser-login.d.ts.map +1 -1
- package/lib/magicrew-browser-login.js +73 -15
- package/lib/magicrew-browser-login.js.map +1 -1
- package/lib/magicrew-catalog.d.ts.map +1 -1
- package/lib/magicrew-catalog.js +3 -0
- package/lib/magicrew-catalog.js.map +1 -1
- package/lib/magicrew-credits.d.ts +35 -3
- package/lib/magicrew-credits.d.ts.map +1 -1
- package/lib/magicrew-credits.js +215 -10
- package/lib/magicrew-credits.js.map +1 -1
- package/lib/magicrew-local-browser.d.ts +8 -1
- package/lib/magicrew-local-browser.d.ts.map +1 -1
- package/lib/magicrew-local-browser.js +117 -15
- package/lib/magicrew-local-browser.js.map +1 -1
- package/lib/magicrew-profile.d.ts.map +1 -1
- package/lib/magicrew-profile.js +3 -0
- package/lib/magicrew-profile.js.map +1 -1
- package/lib/minimax-adapter.d.ts +5 -0
- package/lib/minimax-adapter.d.ts.map +1 -1
- package/lib/minimax-adapter.js +7 -1
- package/lib/minimax-adapter.js.map +1 -1
- package/lib/model-catalog.d.ts +4 -2
- package/lib/model-catalog.d.ts.map +1 -1
- package/lib/model-catalog.js +9 -6
- package/lib/model-catalog.js.map +1 -1
- package/lib/models-dev-cache.d.ts +27 -0
- package/lib/models-dev-cache.d.ts.map +1 -1
- package/lib/models-dev-cache.js +35 -2
- package/lib/models-dev-cache.js.map +1 -1
- package/lib/monkeycode-adapter.d.ts +8 -0
- package/lib/monkeycode-adapter.d.ts.map +1 -1
- package/lib/monkeycode-adapter.js +7 -2
- package/lib/monkeycode-adapter.js.map +1 -1
- package/lib/monkeycode-credits.d.ts.map +1 -1
- package/lib/monkeycode-credits.js +6 -3
- package/lib/monkeycode-credits.js.map +1 -1
- package/lib/monkeycode-http.d.ts +43 -0
- package/lib/monkeycode-http.d.ts.map +1 -0
- package/lib/monkeycode-http.js +267 -0
- package/lib/monkeycode-http.js.map +1 -0
- package/lib/monkeycode-messages.d.ts.map +1 -1
- package/lib/monkeycode-messages.js +44 -2
- package/lib/monkeycode-messages.js.map +1 -1
- package/lib/provider-credits.d.ts.map +1 -1
- package/lib/provider-credits.js +37 -13
- package/lib/provider-credits.js.map +1 -1
- package/lib/provider-http-pool.d.ts +10 -0
- package/lib/provider-http-pool.d.ts.map +1 -1
- package/lib/provider-http-pool.js +153 -5
- package/lib/provider-http-pool.js.map +1 -1
- package/lib/qoder-catalog.d.ts +64 -12
- package/lib/qoder-catalog.d.ts.map +1 -1
- package/lib/qoder-catalog.js +89 -15
- package/lib/qoder-catalog.js.map +1 -1
- package/lib/qoder-wasm.d.ts.map +1 -1
- package/lib/qoder-wasm.js +19 -2
- package/lib/qoder-wasm.js.map +1 -1
- package/lib/raccoon-adapter.d.ts +27 -36
- package/lib/raccoon-adapter.d.ts.map +1 -1
- package/lib/raccoon-adapter.js +120 -16
- package/lib/raccoon-adapter.js.map +1 -1
- package/lib/types.d.ts +41 -2
- package/lib/types.d.ts.map +1 -1
- package/lib/types.js.map +1 -1
- package/lib/zcode-adapter.d.ts.map +1 -1
- package/lib/zcode-adapter.js +9 -0
- package/lib/zcode-adapter.js.map +1 -1
- package/lib/zcode-diagnostics.d.ts +11 -0
- package/lib/zcode-diagnostics.d.ts.map +1 -1
- package/lib/zcode-diagnostics.js +7 -0
- package/lib/zcode-diagnostics.js.map +1 -1
- package/lib/zcode-identity.d.ts +54 -20
- package/lib/zcode-identity.d.ts.map +1 -1
- package/lib/zcode-identity.js +56 -22
- package/lib/zcode-identity.js.map +1 -1
- package/lib/zcode-upstream.d.ts +33 -2
- package/lib/zcode-upstream.d.ts.map +1 -1
- package/lib/zcode-upstream.js +36 -3
- package/lib/zcode-upstream.js.map +1 -1
- package/package.json +3 -2
package/lib/jet-hub-rpc.js
CHANGED
|
@@ -570,10 +570,13 @@ export function computeClaimSummary(outcomes) {
|
|
|
570
570
|
/**
|
|
571
571
|
* `credits.status` 逐账号查询的**默认并发度**。
|
|
572
572
|
*
|
|
573
|
-
*
|
|
573
|
+
* 6 的依据与代价见 `collectCreditsStatus` 函数体内那段注释(**不要**用「浏览器
|
|
574
574
|
* 默认 6」来论证 —— 那是不同量纲)。
|
|
575
|
+
*
|
|
576
|
+
* 变更史:3(2026-10-22 引入并发)→ 6(2026-11-06,用户反馈「线程池的并发
|
|
577
|
+
* 能力还是太弱了」;依据见下方 `MAX` 常量与函数体注释)。
|
|
575
578
|
*/
|
|
576
|
-
export const DEFAULT_CREDITS_STATUS_CONCURRENCY =
|
|
579
|
+
export const DEFAULT_CREDITS_STATUS_CONCURRENCY = 6;
|
|
577
580
|
/**
|
|
578
581
|
* `credits.status` 逐账号查询的**并发硬上界**。
|
|
579
582
|
*
|
|
@@ -591,24 +594,96 @@ export const DEFAULT_CREDITS_STATUS_CONCURRENCY = 3;
|
|
|
591
594
|
*
|
|
592
595
|
* ⇒ 上界改为本常量。它同时给「将来有人把默认值调大」加了一道闸。
|
|
593
596
|
*
|
|
594
|
-
*
|
|
595
|
-
*
|
|
597
|
+
* ## 取值(2026-11-06:8 → 16)
|
|
598
|
+
*
|
|
599
|
+
* 用户反馈「线程池的并发能力还是太弱了」。逐项重核(见函数体注释的三条依据)后
|
|
600
|
+
* 调整:能走到这里的只有 4 家的**只读、一次/账号**状态查询,429 无重试放大 ⇒
|
|
601
|
+
* 把天花板从 8 抬到 16 不会把限流失败变成重试风暴;16 足够让 30+ 账号的池子
|
|
602
|
+
* 在「默认 6」之上再翻近 3 倍吞吐(想串行/降档的仍可传 `1` 或设小值)。
|
|
603
|
+
*
|
|
604
|
+
* ⚠️ 16 仍是「远低于任何一家上游会当成爬虫的量级」的保守取值;再调大需要
|
|
605
|
+
* 重新核对 `fetchStatus` 各家(minimax / minimaxintl / buddy / workbuddy)的
|
|
606
|
+
* 限流策略。
|
|
607
|
+
*/
|
|
608
|
+
export const MAX_CREDITS_STATUS_CONCURRENCY = 16;
|
|
609
|
+
/**
|
|
610
|
+
* 读环境变量 `DSH_CREDITS_STATUS_CONCURRENCY`(**运行期调参**,2026-11-06 加)。
|
|
611
|
+
*
|
|
612
|
+
* 背景:默认 6 对多数用户够用,但「账号很多 + 上游慢」的组合仍想再压榨吞吐。
|
|
613
|
+
* 与 `DSH_ZCODE_TRANSIENT_RETRY_DELAY_MS` 等既有调参钮同款形态:默认不开、
|
|
614
|
+
* 设置即生效,避免为调一个数字再发一版。
|
|
615
|
+
*
|
|
616
|
+
* 解析规则(**严格**,与 `resolveCreditsStatusConcurrency` 的回落语义对齐):
|
|
617
|
+
* - 未设置 / 空串 ⇒ `undefined`(用默认 6);
|
|
618
|
+
* - 非法值(非数字、`0`、负数、小数、非安全整数、`Infinity`)⇒ `undefined` ——
|
|
619
|
+
* **宁可回落默认也不猜**(对齐 zcode 系 env 解析的纪律);
|
|
620
|
+
* - 合法值 ⇒ 原样返回(后续仍会被 {@link MAX_CREDITS_STATUS_CONCURRENCY} 硬顶)。
|
|
621
|
+
*
|
|
622
|
+
* 纯读 `process.env`,可直接单测(vitest 里 `process.env.X = '…'` 即可注入)。
|
|
623
|
+
*/
|
|
624
|
+
export function readCreditsStatusConcurrencyEnv() {
|
|
625
|
+
const raw = process.env.DSH_CREDITS_STATUS_CONCURRENCY;
|
|
626
|
+
if (raw === undefined || raw.trim() === '')
|
|
627
|
+
return undefined;
|
|
628
|
+
const parsed = Number(raw);
|
|
629
|
+
return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined;
|
|
630
|
+
}
|
|
631
|
+
/**
|
|
632
|
+
* worker 启动错峰的**默认窗口**(毫秒,2026-11-06 加)。
|
|
633
|
+
*
|
|
634
|
+
* ## 为什么需要(用户反馈「高并发的时候,不稳定」)
|
|
635
|
+
*
|
|
636
|
+
* 提档并发后(默认 6),一轮 `credits.status` 的第一波请求会在**同一毫秒**里
|
|
637
|
+
* 齐发 —— 对上游是瞬时突刺(连接握手同时建、限流窗口同时撞),对共享
|
|
638
|
+
* undici 池是瞬时排队。这正是「高并发不稳定」的形态之一:偶发、与时钟对齐、
|
|
639
|
+
* 并发度越高概率越大。
|
|
640
|
+
*
|
|
641
|
+
* 错峰把「同一毫秒齐发」摊成「窗口内随机散开」(每个 worker 启动前睡
|
|
642
|
+
* `random() × jitterMs`)。稳态吞吐不受影响(worker 一旦跑起来就靠各自的
|
|
643
|
+
* 完成时刻自然错开,错峰只在**启动瞬间**起作用),代价是首轮平均慢
|
|
644
|
+
* `jitterMs / 2`(默认 25 ms,对比单账号上游 30 s 超时可忽略)。
|
|
645
|
+
*
|
|
646
|
+
* ⚠️ 并发度 ≤ 1 时**不睡**(没有可错峰的对象);`0` 显式关闭。
|
|
647
|
+
*/
|
|
648
|
+
export const DEFAULT_CREDITS_STATUS_JITTER_MS = 50;
|
|
649
|
+
/**
|
|
650
|
+
* 错峰窗口的环境变量硬上界(毫秒):防 `DSH_CREDITS_STATUS_JITTER_MS=999999`
|
|
651
|
+
* 把一轮状态查询拖成分钟级。设置超过它按它截断。
|
|
596
652
|
*/
|
|
597
|
-
export const
|
|
653
|
+
export const MAX_CREDITS_STATUS_JITTER_MS = 2_000;
|
|
654
|
+
/**
|
|
655
|
+
* 读环境变量 `DSH_CREDITS_STATUS_JITTER_MS`(**运行期调参**,2026-11-06 加)。
|
|
656
|
+
*
|
|
657
|
+
* 解析规则(与 {@link readCreditsStatusConcurrencyEnv} 同纪律):
|
|
658
|
+
* - 未设置 / 空串 ⇒ 默认 {@link DEFAULT_CREDITS_STATUS_JITTER_MS};
|
|
659
|
+
* - `0` ⇒ **合法值**(显式关闭错峰,不是「回落默认」—— 它是唯一的关法);
|
|
660
|
+
* - 负数 / 非数字 / `Infinity` ⇒ 回落默认(宁可回落也不猜);
|
|
661
|
+
* - 小数 ⇒ 向下取整(`0.5` ⇒ `0`,即关闭);
|
|
662
|
+
* - 超过 {@link MAX_CREDITS_STATUS_JITTER_MS} ⇒ 截断到上界。
|
|
663
|
+
*/
|
|
664
|
+
export function readCreditsStatusJitterMsEnv() {
|
|
665
|
+
const raw = process.env.DSH_CREDITS_STATUS_JITTER_MS;
|
|
666
|
+
if (raw === undefined || raw.trim() === '')
|
|
667
|
+
return DEFAULT_CREDITS_STATUS_JITTER_MS;
|
|
668
|
+
const parsed = Number(raw);
|
|
669
|
+
if (!Number.isFinite(parsed) || parsed < 0)
|
|
670
|
+
return DEFAULT_CREDITS_STATUS_JITTER_MS;
|
|
671
|
+
return Math.min(Math.floor(parsed), MAX_CREDITS_STATUS_JITTER_MS);
|
|
672
|
+
}
|
|
598
673
|
/**
|
|
599
674
|
* 解析 `credits.status` 的并发度(**纯函数,可直接单测**)。
|
|
600
675
|
*
|
|
601
|
-
* 逐格行为(2026-10-22
|
|
676
|
+
* 逐格行为(2026-10-22 审计逐格实测确认;默认值 2026-11-06 起为 6):
|
|
602
677
|
*
|
|
603
678
|
* | 传入 | 结果 | 说明 |
|
|
604
679
|
* |---|---|---|
|
|
605
|
-
* | `undefined` / `0` / `-1` / `NaN` / `1.5` / `Infinity` / 字符串 |
|
|
680
|
+
* | `undefined` / `0` / `-1` / `NaN` / `1.5` / `Infinity` / 字符串 | 6 | 非「正整数」一律回落默认 |
|
|
606
681
|
* | `1` | 1 | 恢复旧的完全串行语义 |
|
|
607
682
|
* | `4` | 4 | |
|
|
608
|
-
* | `1e10` / `MAX_SAFE_INTEGER` | **
|
|
683
|
+
* | `1e10` / `MAX_SAFE_INTEGER` | **16** | 被 {@link MAX_CREDITS_STATUS_CONCURRENCY} 硬顶(初版这里会变成账号数) |
|
|
609
684
|
* | `accounts.length === 0` | 1 | 起 1 个 worker 立刻返回 -1(**不能**是 0 —— 那会让 `results` 全是空洞) |
|
|
610
685
|
*
|
|
611
|
-
* ⚠️ `concurrency: 0` 的语义是「**回落默认
|
|
686
|
+
* ⚠️ `concurrency: 0` 的语义是「**回落默认 6**」,**不是**「串行」——要串行请传 `1`。
|
|
612
687
|
* 这条在初版注释里没写,是审计点出来的语义空隙。
|
|
613
688
|
*/
|
|
614
689
|
export function resolveCreditsStatusConcurrency(raw, accountCount) {
|
|
@@ -621,11 +696,17 @@ export function resolveCreditsStatusConcurrency(raw, accountCount) {
|
|
|
621
696
|
return Math.max(1, Math.min(capped, accountCount || 1));
|
|
622
697
|
}
|
|
623
698
|
/**
|
|
624
|
-
* 逐账号收集签到状态(**有限并发**,默认
|
|
699
|
+
* 逐账号收集签到状态(**有限并发**,默认 6;见函数体内 `concurrency` 的说明)。
|
|
625
700
|
*
|
|
626
701
|
* ⚠️ **原实现是纯串行**,注释写「顺序执行,避免并发触发风控」。2026-10-22 改成
|
|
627
702
|
* 有限并发,理由与代价见函数体内那段长注释 —— **别再照旧注释改回串行**。
|
|
628
703
|
*
|
|
704
|
+
* ★ 2026-11-06 高并发稳定性(用户反馈「高并发的时候,不稳定」):提档并发
|
|
705
|
+
* (默认 6 / 硬顶 16)的同时加了两个守卫 —— worker **启动错峰**与**整波失败
|
|
706
|
+
* 熔断**(任一路成功即永不熔断;串行兼容模式不熔断)。机制与论证见函数体内
|
|
707
|
+
* 「★ 高并发稳定性守卫」一节;运行期调参钮 `DSH_CREDITS_STATUS_CONCURRENCY`
|
|
708
|
+
* 与 `DSH_CREDITS_STATUS_JITTER_MS`。
|
|
709
|
+
*
|
|
629
710
|
* **包含已停用账号**:停用只影响账号池的自动选择与限流切换,不改变账号本身
|
|
630
711
|
* 是否已签到。用户要看到的是「这个账号今天领了没」,因此这里不过滤 enabled。
|
|
631
712
|
*
|
|
@@ -641,7 +722,7 @@ export async function collectCreditsStatus(accounts, product, deps) {
|
|
|
641
722
|
const fetchStatus = deps.fetchStatus
|
|
642
723
|
?? (async (credential, product) => fetchCheckinStatus(credential, product, fetcher));
|
|
643
724
|
/**
|
|
644
|
-
* **有限并发**(2026-10-22
|
|
725
|
+
* **有限并发**(2026-10-22 引入,2026-11-06 提档 3→6、天花板 8→16)。
|
|
645
726
|
*
|
|
646
727
|
* ## 为什么不再「完全串行」
|
|
647
728
|
*
|
|
@@ -650,7 +731,7 @@ export async function collectCreditsStatus(accounts, product, deps) {
|
|
|
650
731
|
* ⇒ 「打开 Jet Hub 设置页」的等待被账号数线性放大。同一时刻 `model.list` 只要
|
|
651
732
|
* 毫秒级(⇒ 慢的不是读目录,是这里)。
|
|
652
733
|
*
|
|
653
|
-
* ##
|
|
734
|
+
* ## 为什么 3 不够、6 可以(2026-11-06 用户反馈「线程池的并发能力还是太弱了」)
|
|
654
735
|
*
|
|
655
736
|
* 原注释的理由是「顺序查询避免并发触发风控」。逐项核对后的**真实依据**是:
|
|
656
737
|
*
|
|
@@ -667,12 +748,43 @@ export async function collectCreditsStatus(accounts, product, deps) {
|
|
|
667
748
|
* `workbuddy.fetchStatus` 的注释)⇒ 四家都是**只读状态查询、一次/账号**。
|
|
668
749
|
* - **429 不会被放大**:`minimax` 的 `minimaxFetchWithRetry` 只重试**传输错误**,
|
|
669
750
|
* 而 `buddy` 系走的 `credits.ts` `postJson` **同样不重试 HTTP 状态**
|
|
670
|
-
* (实测:该文件里 `429` / `retry` 零命中)⇒
|
|
751
|
+
* (实测:该文件里 `429` / `retry` 零命中)⇒ 6 并发撞限流只是 6 条同时失败,
|
|
671
752
|
* 不会变成重试风暴;
|
|
672
753
|
* - 签到(**写操作**)走的是 `collectClaimResults`,那里**仍是串行**,本改动不碰它。
|
|
673
754
|
*
|
|
674
|
-
*
|
|
675
|
-
*
|
|
755
|
+
* **2026-11-06 提档的论证**:上面三条依据在「并发度 = 3」时成立,在 6/16 下
|
|
756
|
+
* **同样成立**(它们约束的是「失败形态不放大」,不是「3 这个数字」)。真正随
|
|
757
|
+
* 并发度变化的是「同一瞬时打到同一上游的请求数」:4 家全是**只读、一次/账号**
|
|
758
|
+
* 的批量状态同步 —— 6/16 是「一轮里同时问 6/16 个账号」的量级,不是**持续**
|
|
759
|
+
* 高频轮询(后者才是风控画像)。收益侧:默认 3 时 30 个账号的池子稳态吞吐 =
|
|
760
|
+
* 3 × (1/单账号耗时),提档到 6 直接翻倍;天花板 16 给「账号很多 + 上游慢」的
|
|
761
|
+
* 场景留出经 `DSH_CREDITS_STATUS_CONCURRENCY` 调参的余量。
|
|
762
|
+
*
|
|
763
|
+
* ⚠️ 因此**不要**照「X 远低于浏览器默认的 6」那条类比来论证安全性(浏览器并发
|
|
764
|
+
* 与服务端风控不是同一量纲,那是初版注释的推理错误)。要论证就按上面三条 +
|
|
765
|
+
* 提档论证段。
|
|
766
|
+
*
|
|
767
|
+
* ## ★ 高并发稳定性守卫(2026-11-06,用户反馈「高并发的时候,不稳定」)
|
|
768
|
+
*
|
|
769
|
+
* 提档并发放大了两个**只在并发时存在**的失败形态,各配一个守卫:
|
|
770
|
+
*
|
|
771
|
+
* 1. **启动突刺**:N 个 worker 在同一毫秒齐发第一波(握手同时建、限流窗口
|
|
772
|
+
* 同时撞、共享 undici 池瞬时排队)⇒ 守卫是**启动错峰**:每个 worker 启动前
|
|
773
|
+
* 睡 `random() × jitterMs`(默认 50 ms,`DSH_CREDITS_STATUS_JITTER_MS` 可调,
|
|
774
|
+
* `0` 关闭;并发 ≤ 1 不睡)。稳态吞吐不变,首轮平均只慢 25 ms。
|
|
775
|
+
*
|
|
776
|
+
* 2. **整波全灭还在烧**:上游被限流/断网时,6 并发的第一波全失败,而**队列里
|
|
777
|
+
* 的账号还会继续被领出去**打同一个不可用的上游 —— 31 个账号最坏烧满 31 发
|
|
778
|
+
* 还拖满整轮超时。⇒ 守卫是**整波失败熔断**:`成功数 === 0 且 失败数 ≥ 首波
|
|
779
|
+
* 宽度`时,`take()` 停止发牌,剩余账号**零请求**直接记 `status: null`
|
|
780
|
+
* (与「查询失败」同一展示语义)+ 一条汇总 warn。在途请求**不掐**(本仓库
|
|
781
|
+
* 纪律:不主动掐上游连接,避免重试风暴 —— 与 `aggregate-expiry` 的预算
|
|
782
|
+
* 超时不取消在途 fetch 同款)。
|
|
783
|
+
* - 阈值 `max(2, min(concurrency, 账号数))`:**任何一路成功过就永不熔断**
|
|
784
|
+
* (断路器只在「从开局起零成功」才可能触发 ⇒ 单账号凭据坏 / 混合失败
|
|
785
|
+
* 绝不会误伤 —— 「单个账号失败不中断整体」的既有契约原样保留);
|
|
786
|
+
* - ⚠️ `concurrency = 1`(串行兼容模式)**刻意不熔断**:那条通道的意义就是
|
|
787
|
+
* 「逐字节复现旧串行语义」,给它加熔断等于改写历史行为。
|
|
676
788
|
*
|
|
677
789
|
* ## 顺序与逃逸
|
|
678
790
|
*
|
|
@@ -681,16 +793,61 @@ export async function collectCreditsStatus(accounts, product, deps) {
|
|
|
681
793
|
* - ⚠️ `deps.warn` 抛错**不得**逃逸成整批失败(初版会:它在 catch 里调用,
|
|
682
794
|
* 一抛就把 worker 的 promise reject 掉)⇒ 已包 try。
|
|
683
795
|
*
|
|
684
|
-
* ⚠️ 并发度可通过 `deps.concurrency`
|
|
685
|
-
* `
|
|
796
|
+
* ⚠️ 并发度可通过 `deps.concurrency` 覆盖(测试注入;生产则用环境变量
|
|
797
|
+
* `DSH_CREDITS_STATUS_CONCURRENCY` 调参,见 {@link readCreditsStatusConcurrencyEnv});
|
|
798
|
+
* `1` 即恢复旧的完全串行语义(含「不熔断」)。上界是 {@link MAX_CREDITS_STATUS_CONCURRENCY}
|
|
686
799
|
* (**不是** `accounts.length` —— 那会让 31 个账号变成 31 并发)。
|
|
687
800
|
*/
|
|
688
|
-
|
|
801
|
+
// ⚠️ 优先级:deps.concurrency(测试注入)> DSH_CREDITS_STATUS_CONCURRENCY
|
|
802
|
+
// (env,运行期调参)> 默认 6。env 只在这一个入口折叠一次,
|
|
803
|
+
// `resolveCreditsStatusConcurrency` 保持纯函数(单测不碰 env)。
|
|
804
|
+
const concurrency = resolveCreditsStatusConcurrency(deps.concurrency ?? readCreditsStatusConcurrencyEnv(), accounts.length);
|
|
805
|
+
// ★ 稳定性守卫 1/2 —— 启动错峰:并发 ≤ 1 时没有可错峰的对象,不睡。
|
|
806
|
+
const jitterMs = concurrency > 1 ? readCreditsStatusJitterMsEnv() : 0;
|
|
807
|
+
/**
|
|
808
|
+
* ★ 稳定性守卫 2/2 —— 整波失败熔断的阈值。
|
|
809
|
+
*
|
|
810
|
+
* `concurrency >= 2` 才启用(串行兼容模式不熔断,见上方长注释);
|
|
811
|
+
* `max(2, …)` 保证阈值至少 2 —— 「首波宽度 2」时单次失败不该熔断(那还够不上
|
|
812
|
+
* 「整波全灭」的证据强度)。`Infinity` = 永不熔断(串行)。
|
|
813
|
+
*/
|
|
814
|
+
const breakerThreshold = concurrency >= 2
|
|
815
|
+
? Math.max(2, Math.min(concurrency, accounts.length))
|
|
816
|
+
: Number.POSITIVE_INFINITY;
|
|
817
|
+
/** 批内成功 / 失败计数(同步更新,单线程下无需加锁);熔断判据只看开局。 */
|
|
818
|
+
let failureCount = 0;
|
|
819
|
+
let successCount = 0;
|
|
820
|
+
let breakerTripped = false;
|
|
689
821
|
const results = new Array(accounts.length);
|
|
690
822
|
let cursor = 0;
|
|
691
|
-
/**
|
|
692
|
-
|
|
823
|
+
/**
|
|
824
|
+
* 取下一个待处理下标;无剩余返回 -1(同步自增,单线程下无需加锁)。
|
|
825
|
+
*
|
|
826
|
+
* ★ 熔断检查在**发牌时**同步做(而不是在完成回调里):JS 单线程 ⇒ take 与
|
|
827
|
+
* 完成回调不会交错,判据无需加锁;挂在 take 上还天然覆盖「熔断后 worker 手里
|
|
828
|
+
* 没牌就退出」。已发出去的在途请求**不收**(见长注释的「不掐」纪律)。
|
|
829
|
+
*/
|
|
830
|
+
const take = () => {
|
|
831
|
+
if (!breakerTripped && successCount === 0 && failureCount >= breakerThreshold) {
|
|
832
|
+
breakerTripped = true;
|
|
833
|
+
// 汇总告警只发一条(整批一次,不是逐账号一次);warn 自身可能抛 ⇒ 包 try。
|
|
834
|
+
try {
|
|
835
|
+
deps.warn?.(`[jet-hub] credits.status 熔断:开局 ${failureCount} 个账号全部失败且无一成功,`
|
|
836
|
+
+ `剩余 ${accounts.length - cursor} 个账号本轮跳过(上游疑似不可用/被限流),`
|
|
837
|
+
+ `逐账号失败原因见上方告警`);
|
|
838
|
+
}
|
|
839
|
+
catch {
|
|
840
|
+
// 告警失败只能静默:这里已经没有更外层的可观测通道了。
|
|
841
|
+
}
|
|
842
|
+
return -1;
|
|
843
|
+
}
|
|
844
|
+
return cursor < accounts.length ? cursor++ : -1;
|
|
845
|
+
};
|
|
693
846
|
const worker = async () => {
|
|
847
|
+
// ★ 启动错峰:只在 worker 启动瞬间睡一次(随机 × 窗口),摊平第一波突刺。
|
|
848
|
+
if (jitterMs > 0) {
|
|
849
|
+
await new Promise((resolve) => { setTimeout(resolve, Math.random() * jitterMs); });
|
|
850
|
+
}
|
|
694
851
|
for (let index = take(); index !== -1; index = take()) {
|
|
695
852
|
const entry = accounts[index];
|
|
696
853
|
/**
|
|
@@ -734,11 +891,37 @@ export async function collectCreditsStatus(accounts, product, deps) {
|
|
|
734
891
|
// 告警失败只能静默:这里已经没有更外层的可观测通道了。
|
|
735
892
|
}
|
|
736
893
|
}
|
|
894
|
+
// ★ 熔断计数:`status === null` 与「fetchStatus 抛错」都算失败
|
|
895
|
+
// (两者对用户是同一展示语义);任何非 null 结果都算成功并**永久解除**
|
|
896
|
+
// 熔断可能(判据要求 successCount === 0)。放在纯赋值之前、同一同步块,
|
|
897
|
+
// 与 take() 的读取天然串行(单线程)。
|
|
898
|
+
if (status === null)
|
|
899
|
+
failureCount++;
|
|
900
|
+
else
|
|
901
|
+
successCount++;
|
|
737
902
|
// ⚠️ 纯赋值,不得再抛(`Promise.all` 会因 worker reject 而短路整批)。
|
|
738
903
|
results[index] = { accountId, nickname, status };
|
|
739
904
|
}
|
|
740
905
|
};
|
|
741
906
|
await Promise.all(Array.from({ length: concurrency }, worker));
|
|
907
|
+
// ★ 熔断(或任何未跑满的路径)后补齐尾部账号:结果数组必须与 accounts 等长、
|
|
908
|
+
// 按原序含每个账号(UI 按下标渲染)—— 跳过的账号如实记 `status: null`
|
|
909
|
+
// (「查询失败/未知」的既有展示语义),**零网络请求**。
|
|
910
|
+
// ⚠️ 与 worker 内同款的防御性读取:`entry` 是外部对象,id/nickname 的 getter
|
|
911
|
+
// 可能抛;抛了就落 undefined(与单账号失败路径的兜底一致)。
|
|
912
|
+
for (; cursor < accounts.length; cursor++) {
|
|
913
|
+
const entry = accounts[cursor];
|
|
914
|
+
let accountId;
|
|
915
|
+
let nickname;
|
|
916
|
+
try {
|
|
917
|
+
accountId = entry.id;
|
|
918
|
+
nickname = entry.nickname;
|
|
919
|
+
}
|
|
920
|
+
catch {
|
|
921
|
+
// getter 抛错 ⇒ 落 undefined(与 worker 内的兜底同语义)。
|
|
922
|
+
}
|
|
923
|
+
results[cursor] = { accountId, nickname, status: null };
|
|
924
|
+
}
|
|
742
925
|
return results;
|
|
743
926
|
}
|
|
744
927
|
/**
|
|
@@ -893,7 +1076,8 @@ export async function collectCreditBalances(accounts, product, deps) {
|
|
|
893
1076
|
/**
|
|
894
1077
|
* ⚠️ **这里仍是串行**(与 `collectCreditsStatus` 的有限并发**刻意不同**)。
|
|
895
1078
|
*
|
|
896
|
-
* `collectCreditsStatus` 于 2026-10-22
|
|
1079
|
+
* `collectCreditsStatus` 于 2026-10-22 改成有限并发(2026-11-06 起默认 6),
|
|
1080
|
+
* 本函数**没有**跟着改,
|
|
897
1081
|
* 理由是两者接的上游不同:那个只服务 `minimax` / `minimaxintl` 的**只读 GET**,
|
|
898
1082
|
* 而本函数是面板「刷新积分」的主路径,各家余额接口都有速率限制(且部分带写语义,
|
|
899
1083
|
* 例如 astudio 的 `importLocalSession`、minimax 的积分端点),并发收益不明而风险
|
|
@@ -1273,8 +1457,16 @@ async function fullCatalogIds(ctx, modelAdapters, provider) {
|
|
|
1273
1457
|
// ⚠️ 它抛错**不独自决定成败**:远端那一半仍可能成功,故单独吞掉。
|
|
1274
1458
|
const adapterIds = [];
|
|
1275
1459
|
try {
|
|
1276
|
-
|
|
1277
|
-
|
|
1460
|
+
// ⚠️ **必须校验形状**(2026-11-05 四审端到端 P2-2):适配器的类型契约是
|
|
1461
|
+
// `LlmModelInfo[]`,但那是**编译期**保证。运行期若某个第三方/桩实现返回
|
|
1462
|
+
// 字符串数组,`.id` 会取到 `undefined` ⇒ 黑名单被写成 `{"undefined":true}`
|
|
1463
|
+
//(静默落盘、且 `total` 随之虚高)。实测:桩返回 `['a','b']` ⇒ 黑名单
|
|
1464
|
+
// `{"a":true,"b":true,"undefined":true}`、状态 `{total:3,disabled:3}`。
|
|
1465
|
+
// 过滤是**零成本**的(正常实现每条都过),故不必区分「该不该防」。
|
|
1466
|
+
for (const model of modelAdapters?.[provider]?.listAllModels() ?? []) {
|
|
1467
|
+
if (typeof model?.id === 'string' && model.id.length > 0)
|
|
1468
|
+
adapterIds.push(model.id);
|
|
1469
|
+
}
|
|
1278
1470
|
}
|
|
1279
1471
|
catch {
|
|
1280
1472
|
/* 适配器异常不该让整个读取失败:远端目录仍可用 */
|
|
@@ -1287,8 +1479,11 @@ async function fullCatalogIds(ctx, modelAdapters, provider) {
|
|
|
1287
1479
|
}
|
|
1288
1480
|
let remoteIds;
|
|
1289
1481
|
try {
|
|
1482
|
+
// ⚠️ 同样校验形状(理由见上面 `adapterIds` 处;远端那份更值得防 —— 它是
|
|
1483
|
+
// **网络来的**数据,上游一次改契约就会让 `undefined` 混进黑名单)。
|
|
1290
1484
|
remoteIds = (await withTimeout(llm.listModels(provider), CATALOG_READ_TIMEOUT_MS))
|
|
1291
|
-
.map((model) => model
|
|
1485
|
+
.map((model) => model?.id)
|
|
1486
|
+
.filter((id) => typeof id === 'string' && id.length > 0);
|
|
1292
1487
|
}
|
|
1293
1488
|
catch (error) {
|
|
1294
1489
|
const reason = error instanceof Error ? error.message : String(error);
|
|
@@ -1454,7 +1649,13 @@ function withTimeout(promise, ms) {
|
|
|
1454
1649
|
* @param pool - 读黑名单(**在 await 之后**,理由见上)。
|
|
1455
1650
|
* @param modelAdapters - 设置页目录来源(并集的一半)。
|
|
1456
1651
|
* @param provider - 目标 provider。
|
|
1457
|
-
* @returns 可核对的目录 id 集合;`undefined` = **放弃核对**(三种情况见上)。
|
|
1652
|
+
* @returns `known` = 可核对的目录 id 集合;`undefined` = **放弃核对**(三种情况见上)。
|
|
1653
|
+
* `catalog` = {@link fullCatalogIds} 的**原始并集结果**(不并黑名单)。
|
|
1654
|
+
* ⚠️ 两者**不可混用**:`known` 是 `catalog.ids` **并回黑名单**后的派生值,
|
|
1655
|
+
* 拿它判「本次写入是否覆盖该家全量目录」**恒真**(等于「关一个模型就关掉
|
|
1656
|
+
* 整个供应商」)—— 那个判据只能用 `catalog.ids`,见 `model.setDisabledMany`。
|
|
1657
|
+
* ⚠️ 顺带返回 `catalog` 是为了让关闭方向**不必再取一次目录**
|
|
1658
|
+
* (`fullCatalogIds` 冷缓存下真的会发远端拉取,多调一次就多一条网络依赖)。
|
|
1458
1659
|
*/
|
|
1459
1660
|
async function readableCatalogIds(ctx, pool, modelAdapters, provider) {
|
|
1460
1661
|
const catalog = await fullCatalogIds(ctx, modelAdapters, provider);
|
|
@@ -1466,7 +1667,7 @@ async function readableCatalogIds(ctx, pool, modelAdapters, provider) {
|
|
|
1466
1667
|
// 不得退化成「只用 listAllModels 兜底表」:那会退回第一版的大面积误报。
|
|
1467
1668
|
// 提示层错了不如不说。
|
|
1468
1669
|
if (!catalog.complete)
|
|
1469
|
-
return undefined;
|
|
1670
|
+
return { known: undefined, catalog };
|
|
1470
1671
|
const known = new Set(catalog.ids);
|
|
1471
1672
|
// ⚠️ 并回「被关着」的 id —— **必须在 await 之后读**(理由见函数头)。
|
|
1472
1673
|
// ⚠️ `fullCatalogIds` 的并集**已含**适配器目录里那些被关闭的 id,
|
|
@@ -1476,7 +1677,7 @@ async function readableCatalogIds(ctx, pool, modelAdapters, provider) {
|
|
|
1476
1677
|
if (disabled === true)
|
|
1477
1678
|
known.add(id);
|
|
1478
1679
|
}
|
|
1479
|
-
return known;
|
|
1680
|
+
return { known, catalog };
|
|
1480
1681
|
}
|
|
1481
1682
|
/**
|
|
1482
1683
|
* 为「静默空操作」生成 warnings(纯函数,判据与取舍见 {@link readableCatalogIds})。
|
|
@@ -1520,6 +1721,44 @@ function registerJetHubEndpoints(ctx, pool, auths, modelAdapters) {
|
|
|
1520
1721
|
minimaxintl, zcode, gemini, accio, autoclaw, astudio,
|
|
1521
1722
|
// ⚠️ AutoClaw 国际版(`autoclawintl`)—— 与 `autoclaw` 是**两个实例**。
|
|
1522
1723
|
autoclawintl, } = auths;
|
|
1724
|
+
/**
|
|
1725
|
+
* 在飞的目录核实(single-flight 去重,键 = provider id)。
|
|
1726
|
+
*
|
|
1727
|
+
* ⚠️⚠️ **为什么需要**(2026-11-05 四审端到端 P2-1):`withTimeout` 只
|
|
1728
|
+
* reject 外层 Promise、**不取消**底层请求(`listModels` 不接受 signal,
|
|
1729
|
+
* 见 `withTimeout` 的注释)。而 `provider.status` 会被反复调用
|
|
1730
|
+
*(挂载即发 + 每次 `toggleProvider` 后 + 用户点「重试」),每次都对
|
|
1731
|
+
* 「派生判据说已关闭」的家发一轮核实 ⇒ 上游 5s 才返回时,连发两次就有
|
|
1732
|
+
* **56 个在飞请求**(28 家 × 2 轮,实测:`峰值并发 = 56`、
|
|
1733
|
+
* `listModels 总调用 = 56 次`)。
|
|
1734
|
+
*
|
|
1735
|
+
* 后果是正反馈:请求越多越容易 429,而 429 又会产出 `remoteError`。
|
|
1736
|
+
*
|
|
1737
|
+
* ⇒ 对同一 provider 的在飞核实去重:后来者 `await` 同一个 Promise。
|
|
1738
|
+
* 语义等价(同一时刻的同一份目录),只是不再重复发请求。
|
|
1739
|
+
*
|
|
1740
|
+
* ⚠️ **必须完成后立即清除**(成功与失败都清):目录是**可变**的,
|
|
1741
|
+
* 缓存超过一次「在飞窗口」就会让用户看到过期目录。
|
|
1742
|
+
* ⚠️ 作用域在 `registerJetHubEndpoints` 内(**不是模块级**):测试会创建
|
|
1743
|
+
* 多个实例,模块级 Map 会让它们互相复用对方的 Promise(假绿/假红)。
|
|
1744
|
+
*/
|
|
1745
|
+
const catalogVerifyInFlight = new Map();
|
|
1746
|
+
/**
|
|
1747
|
+
* 对同一 provider 的目录核实做 single-flight(见 `catalogVerifyInFlight`)。
|
|
1748
|
+
*
|
|
1749
|
+
* ⚠️ 只在**同一时刻**去重,不跨请求复用结果 —— 这正是「在飞」而非「缓存」
|
|
1750
|
+
* 的含义。要缓存请另做(本仓库的目录缓存另有其事,见
|
|
1751
|
+
* `src/model-catalog.ts` 的 `invalidateCatalogCache`)。
|
|
1752
|
+
*/
|
|
1753
|
+
const verifyCatalogOnce = (provider) => {
|
|
1754
|
+
const existing = catalogVerifyInFlight.get(provider);
|
|
1755
|
+
if (existing !== undefined)
|
|
1756
|
+
return existing;
|
|
1757
|
+
const pending = fullCatalogIds(ctx, modelAdapters, provider)
|
|
1758
|
+
.finally(() => { catalogVerifyInFlight.delete(provider); });
|
|
1759
|
+
catalogVerifyInFlight.set(provider, pending);
|
|
1760
|
+
return pending;
|
|
1761
|
+
};
|
|
1523
1762
|
/**
|
|
1524
1763
|
* 积分能力表。
|
|
1525
1764
|
*
|
|
@@ -3186,7 +3425,16 @@ function registerJetHubEndpoints(ctx, pool, auths, modelAdapters) {
|
|
|
3186
3425
|
ctx.logger.warn(`[jet-hub] ${String(call.method)} failed: ${message}`);
|
|
3187
3426
|
return reply(rpcId, {
|
|
3188
3427
|
ok: false,
|
|
3189
|
-
error: {
|
|
3428
|
+
error: {
|
|
3429
|
+
// ⚠️ **保留底层错误码**(2026-11-05 四审契约 P2-2):
|
|
3430
|
+
// `EACCES`(改权限)/ `ENOENT`(文件不在)/ `EISDIR` /
|
|
3431
|
+
// `SyntaxError`(文档损坏)的用户动作**完全不同**,全塌成
|
|
3432
|
+
// `handler-failed` 会让客户端无法分支处理,也只能给出「未知故障」。
|
|
3433
|
+
// ⚠️ 客户端目前对 `handler-failed` **零分支**(`grep` 只命中本仓
|
|
3434
|
+
// src 的注释)⇒ 这是纯增量,不会破坏既有契约。
|
|
3435
|
+
code: error?.code ?? 'jet-hub/handler-failed',
|
|
3436
|
+
message,
|
|
3437
|
+
},
|
|
3190
3438
|
});
|
|
3191
3439
|
}
|
|
3192
3440
|
},
|
|
@@ -6823,7 +7071,10 @@ function registerJetHubEndpoints(ctx, pool, auths, modelAdapters) {
|
|
|
6823
7071
|
// ⚠️ `collectCreditsStatus` 逐账号 try/catch —— 单账号失败**不中断整体**,
|
|
6824
7072
|
// 这是该骨架已验证的语义,**不要重写**。
|
|
6825
7073
|
//
|
|
6826
|
-
// ⚠️⚠️ **它已不是「顺序查询」了**(2026-10-22
|
|
7074
|
+
// ⚠️⚠️ **它已不是「顺序查询」了**(2026-10-22 改成有限并发;
|
|
7075
|
+
// 2026-11-06 提档为默认 6、硬顶 16,并加高并发稳定性守卫:
|
|
7076
|
+
// worker 启动错峰 + 整波失败熔断,可用 `DSH_CREDITS_STATUS_CONCURRENCY`
|
|
7077
|
+
// / `DSH_CREDITS_STATUS_JITTER_MS` 调参):
|
|
6827
7078
|
// 原注释写「这与『顺序查询避免并发风控』同属该骨架已验证的语义,不要重写」
|
|
6828
7079
|
// —— 而函数**就在那之后被重写了**,那条注释因此变成误导(下一个读者会照它
|
|
6829
7080
|
// 改回串行)。并发度的依据与代价见 `collectCreditsStatus` 函数体内那段注释。
|
|
@@ -7862,7 +8113,7 @@ function registerJetHubEndpoints(ctx, pool, auths, modelAdapters) {
|
|
|
7862
8113
|
// `listModels()` 过滤掉,写完再读就把它误判成「不在目录」。
|
|
7863
8114
|
// ⚠️ 黑名单**不在这里取** —— `readableCatalogIds` 会在 `await` 之后
|
|
7864
8115
|
// 自己读(理由见其注释:提前取会与写入时刻错开、导致误报「没有变更」)。
|
|
7865
|
-
const known = await readableCatalogIds(ctx, pool, modelAdapters, req.provider);
|
|
8116
|
+
const { known } = await readableCatalogIds(ctx, pool, modelAdapters, req.provider);
|
|
7866
8117
|
await pool.setModelDisabled(req.provider, req.modelId, req.disabled === true);
|
|
7867
8118
|
ctx.logger.info(`[jet-hub] ${req.disabled === true ? '关闭' : '打开'}模型 ${req.provider}/${req.modelId}`);
|
|
7868
8119
|
// 必须广播:否则开关只写进磁盘、界面一直显示旧目录(成因见该函数注释)。
|
|
@@ -7959,11 +8210,72 @@ function registerJetHubEndpoints(ctx, pool, auths, modelAdapters) {
|
|
|
7959
8210
|
}
|
|
7960
8211
|
// 同单条端点:目录必须在写入**之前**读(关闭方向会让 `listModels()`
|
|
7961
8212
|
// 过滤掉这些 id);黑名单由 `readableCatalogIds` 在 `await` 之后自取。
|
|
7962
|
-
const known = await readableCatalogIds(ctx, pool, modelAdapters, req.provider);
|
|
7963
|
-
if (req.disabled)
|
|
7964
|
-
|
|
7965
|
-
|
|
8213
|
+
const { known, catalog } = await readableCatalogIds(ctx, pool, modelAdapters, req.provider);
|
|
8214
|
+
if (req.disabled) {
|
|
8215
|
+
/**
|
|
8216
|
+
* ⚠️⚠️ **关闭方向必须补设「供应商关闭」意图**(本仓补丁,2026-11-05)。
|
|
8217
|
+
*
|
|
8218
|
+
* ## 缺陷形态(与 `model.setAllDisabled` 的 IKP8OF 同一个症状的**第三个入口**)
|
|
8219
|
+
*
|
|
8220
|
+
* 宿主的「供应商开关」与 `provider.status` 是**两套持久语义**:
|
|
8221
|
+
*
|
|
8222
|
+
* - 开关写的是「黑名单 + 关闭意图」两份状态;
|
|
8223
|
+
* - `provider.status` 的 `closed` 判据是 `total > 0 && disabled === total`
|
|
8224
|
+
* (`total` 取自 `listAllModels()`,**含被过滤掉的 id**)。
|
|
8225
|
+
*
|
|
8226
|
+
* 本端点原实现只写黑名单、**从不落意图**。于是:
|
|
8227
|
+
*
|
|
8228
|
+
* 1. 模型列表弹窗把该家**全部**模型按「未勾选」全传进来 ⇒ 黑名单写满全量;
|
|
8229
|
+
* 2. 此刻 `provider.status` 报 `closed: true`(`disabled === total`),
|
|
8230
|
+
* 但 `providerClosed[provider]` 仍是 `false`;
|
|
8231
|
+
* 3. 用户看到「全部已关闭」,点「打开供应商」—— 走
|
|
8232
|
+
* `clearModelsWithProviderClosed`,它按**意图**决定清哪家 ⇒ 清不到;
|
|
8233
|
+
* 4. 弹窗重新打开,34 个模型仍全显示「已在 Jet Hub 关闭」、勾选数 0;
|
|
8234
|
+
* 5. 再点保存 ⇒ 又全传一次。**死循环,用户没有任何出口。**
|
|
8235
|
+
*
|
|
8236
|
+
* 实测(2026-11-05,本机):黑名单 29 家 / 1005 条全 `true`,而
|
|
8237
|
+
* `providerClosed` 只有 2 家(那两家恰好是账号全停用、走
|
|
8238
|
+
* `provider.setEnabled(false)` 关闭的)。历史备份从 830 → 920 → 1005
|
|
8239
|
+
* 一路上涨,说明每保存一次就把当时目录里的全部模型加进黑名单。
|
|
8240
|
+
*
|
|
8241
|
+
* ## 判据:黑名单**覆盖该家全量目录** ⇒ 语义上等价于「关闭供应商」
|
|
8242
|
+
*
|
|
8243
|
+
* ⚠️ **必须用 `catalog.ids`(`fullCatalogIds` 的纯净并集)**,
|
|
8244
|
+
* 不能用 `known` —— 后者已经把黑名单里的 id 并回去了(为了清理历史
|
|
8245
|
+
* 死键),拿它判「全量覆盖」**恒真**,等于「关一个模型就关掉整个
|
|
8246
|
+
* 供应商」。两者不可混用,见 `readableCatalogIds` 的 `@returns`。
|
|
8247
|
+
*
|
|
8248
|
+
* ⚠️ **目录不完整(`complete === false`)时不猜** —— 宁可少设一次
|
|
8249
|
+
* 意图,也不能拿残缺目录把供应商误关掉(与 `setAllDisabled` 的同名
|
|
8250
|
+
* 守卫同源)。`catalog.ids.length > 0` 同理防「空目录 ⇒ every 恒真」。
|
|
8251
|
+
*
|
|
8252
|
+
* ⚠️ **未覆盖全量时走原路径,一个字节都不变** —— 用户只是关掉了某几个
|
|
8253
|
+
* 分组,那与「关闭供应商」是两件事(`setAllDisabled` 的
|
|
8254
|
+
* `closeProvider` 注释也这么写:模型级批量关闭不得顺带关供应商)。
|
|
8255
|
+
*
|
|
8256
|
+
* ⚠️ **黑名单与意图必须同一次落盘** —— `writeModelsWithProviderClosed`
|
|
8257
|
+
* 内部合并好两份状态后只 `queueStoreSave()` 一次;分两次写会留下
|
|
8258
|
+
* 「黑名单满了、意图没写」的半套状态,重启后静默复发。
|
|
8259
|
+
*/
|
|
8260
|
+
const disabledBefore = pool.listDisabledModels(req.provider);
|
|
8261
|
+
const after = { ...disabledBefore };
|
|
8262
|
+
for (const id of ids)
|
|
8263
|
+
after[id] = true;
|
|
8264
|
+
const coversAll = catalog.complete
|
|
8265
|
+
&& catalog.ids.length > 0
|
|
8266
|
+
&& catalog.ids.every((id) => after[id] === true);
|
|
8267
|
+
if (coversAll) {
|
|
8268
|
+
await pool.writeModelsWithProviderClosed(req.provider, ids, true);
|
|
8269
|
+
ctx.logger.info(`[jet-hub] ${req.provider} 的黑名单已覆盖全量目录(${catalog.ids.length} 个),`
|
|
8270
|
+
+ '同时落「供应商关闭」意图');
|
|
8271
|
+
}
|
|
8272
|
+
else {
|
|
8273
|
+
await pool.setModelsDisabled(req.provider, ids);
|
|
8274
|
+
}
|
|
8275
|
+
}
|
|
8276
|
+
else {
|
|
7966
8277
|
await pool.clearModelsDisabled(req.provider, ids);
|
|
8278
|
+
}
|
|
7967
8279
|
ctx.logger.info(`[jet-hub] ${req.disabled ? '关闭' : '打开'} ${req.provider} 的 ${ids.length} 个模型(按分组)`);
|
|
7968
8280
|
// 与其它开关端点一致:必须广播,否则界面一直显示旧目录。
|
|
7969
8281
|
broadcastCatalogChanged(ctx);
|
|
@@ -8025,7 +8337,7 @@ function registerJetHubEndpoints(ctx, pool, auths, modelAdapters) {
|
|
|
8025
8337
|
: undefined;
|
|
8026
8338
|
if (req.disabled && catalog !== undefined) {
|
|
8027
8339
|
// 关闭全部:先取全量目录,再一次性写入黑名单。
|
|
8028
|
-
// ⚠️⚠️
|
|
8340
|
+
// ⚠️⚠️ **判据顺序是语义的一部分**,五条分支按「能否在目录不完整时
|
|
8029
8341
|
// 安全作答」从强到弱排列(下面逐条给理由,别重排):
|
|
8030
8342
|
//
|
|
8031
8343
|
// 1. **远端读失败**(超时/抛错/无 llm 服务)⇒ 拒绝且不落盘。
|
|
@@ -8073,6 +8385,42 @@ function registerJetHubEndpoints(ctx, pool, auths, modelAdapters) {
|
|
|
8073
8385
|
if (pending.length === 0) {
|
|
8074
8386
|
ctx.logger.info(`[jet-hub] ${req.provider} 的全部 ${catalog.ids.length} 个模型本就已关闭,无变更`);
|
|
8075
8387
|
}
|
|
8388
|
+
else if (!catalog.complete && req.closeProvider === false
|
|
8389
|
+
&& catalog.notReady === undefined) {
|
|
8390
|
+
/**
|
|
8391
|
+
* ⚠️⚠️ **模型列表屏的「全关」在「供应商没有账号」时不能拒绝**(2026-11-04 真机报障)。
|
|
8392
|
+
*
|
|
8393
|
+
* 症状(用户原话「部分供应商全关按钮异常」):模型列表屏上 Codeoly (Unity)
|
|
8394
|
+
* 明明显示「5 个 · 已关闭 0」、五个开关全蓝,点「全关」却报
|
|
8395
|
+
* 「该供应商没有可关闭的模型,未做任何变更」——**界面与报错自相矛盾**。
|
|
8396
|
+
*
|
|
8397
|
+
* 成因:该供应商**没有登录账号** ⇒ `llm.listModels()` 被目录门控成 `[]`
|
|
8398
|
+
* ⇒ `complete = remoteIds.length > 0 = false` ⇒ 落到「目录不完整 ⇒ 拒绝」。
|
|
8399
|
+
* 而界面上那 5 个模型来自适配器**兜底表**(`adapterIds`),`catalog.ids`
|
|
8400
|
+
* 本来就是这 5 个 —— 用户要关的正是它们。
|
|
8401
|
+
*
|
|
8402
|
+
* 为什么这一格**可以**放行(与 IKJW33 不矛盾):
|
|
8403
|
+
* - IKJW33 的缺陷形态是「写完整黑名单 + 落**关闭意图**」⇒ `provider.status`
|
|
8404
|
+
* 此后报「已关闭」,而上游其实还有几百个模型可选。本分支落的是
|
|
8405
|
+
* `closeProvider === false`(模型列表屏**从不**写意图,见下面 else 分支
|
|
8406
|
+
* 的注释)⇒ `provider.status` 仍按同一份兜底表算「5 个 · 已关闭 5」,
|
|
8407
|
+
* **状态与事实一致**。
|
|
8408
|
+
* - 用户看不到的模型不会被误报成已关闭;将来登录后新增的模型仍是打开的,
|
|
8409
|
+
* 用户可以再点一次「全关」。
|
|
8410
|
+
*
|
|
8411
|
+
* ⚠️ **`notReady` 一格必须排除**:那是「远端读到了、但目录还没推导完」
|
|
8412
|
+
* (聚合冷启动),此时「可见项」本身是残的,写黑名单会把状态搞错。
|
|
8413
|
+
* ⚠️ `remoteError`(分支 1 已拦)不放行:那是真的读失败,重试可能就好,
|
|
8414
|
+
* 不该写下一份可能残缺的黑名单。
|
|
8415
|
+
*/
|
|
8416
|
+
// ⚠️ 第三参是 `'keep'` **不是** `false`(2026-11-04 修):
|
|
8417
|
+
// `false` 的语义是「删掉该供应商已有的关闭意图」,而本屏从不设置
|
|
8418
|
+
// 意图 ⇒ 传 `false` 会**删除用户在别处设好的关闭状态**
|
|
8419
|
+
// (用户报障「关闭供应商后随更新变回启用」就是这个)。
|
|
8420
|
+
await pool.writeModelsWithProviderClosed(req.provider, pending, 'keep');
|
|
8421
|
+
ctx.logger.info(`[jet-hub] 关闭 ${req.provider} 的 ${pending.length} 个模型`
|
|
8422
|
+
+ '(目录不完整:该供应商未登录或远端无可读目录,只关当前可见项、不动供应商关闭意图)');
|
|
8423
|
+
}
|
|
8076
8424
|
else if (!catalog.complete) {
|
|
8077
8425
|
// 4. **有新增项但目录不完整** ⇒ 拒绝且不落盘。
|
|
8078
8426
|
// ⚠️ 必须排在幂等短路**之后**:先判它会让第 3 条那个正常形态
|
|
@@ -8081,6 +8429,22 @@ function registerJetHubEndpoints(ctx, pool, auths, modelAdapters) {
|
|
|
8081
8429
|
// 而它只是**子集**,据此写黑名单正是本 issue 的原始缺陷。
|
|
8082
8430
|
// ⚠️ 文案与 `provider.setEnabled` **逐字同构**:`remoteError` 有值
|
|
8083
8431
|
// = 「**读不到**」(已在第 1 条拦下);无值 = 「**没账号**」(去登录)。
|
|
8432
|
+
// ⚠️⚠️ **冷帧必须与「无账号」分开说**(二审 P2-1,行为级探针 S4b 实测):
|
|
8433
|
+
// `notReady` 有值 = 聚合目录**还在后台推导**,用户动作是「等一下再点」;
|
|
8434
|
+
// 而「没账号」的动作是「去登录」。两者动作不同 ⇒ 文案不能合并,
|
|
8435
|
+
// 否则冷帧下界面明明列着 5 个模型、报错却说「没有可关闭的模型」。
|
|
8436
|
+
// `provider.setEnabled` 早就分开说了(见它自己的 `notReady` 分支),
|
|
8437
|
+
// 本端点此前漏了 —— 同一份数据、两个端点、两套文案。
|
|
8438
|
+
if (catalog.notReady !== undefined) {
|
|
8439
|
+
return {
|
|
8440
|
+
ok: false,
|
|
8441
|
+
error: {
|
|
8442
|
+
code: 'bad-request',
|
|
8443
|
+
message: `聚合目录尚未读取完成(${catalog.notReady}),`
|
|
8444
|
+
+ '为避免只关闭一部分模型,本次未做任何变更。请稍后重试。',
|
|
8445
|
+
},
|
|
8446
|
+
};
|
|
8447
|
+
}
|
|
8084
8448
|
return {
|
|
8085
8449
|
ok: false,
|
|
8086
8450
|
error: {
|
|
@@ -8111,10 +8475,23 @@ function registerJetHubEndpoints(ctx, pool, auths, modelAdapters) {
|
|
|
8111
8475
|
// 供应商**也关掉(`provider.status` 报 closed、选择器里一个模型都没有)
|
|
8112
8476
|
// ;再打开**任意一个**模型,供应商又被顺带打开(`setModelDisabled` 的
|
|
8113
8477
|
// 打开方向会清意图)⇒ 两头都与用户意图相反,且**零提示**。
|
|
8114
|
-
|
|
8115
|
-
|
|
8478
|
+
// ⚠️⚠️ 第三参 **`'keep'` 而不是 `false`**(2026-11-04 真机报障修复)。
|
|
8479
|
+
//
|
|
8480
|
+
// 上一行的注释说的是「**不落**意图」,而 `false` 的实现是
|
|
8481
|
+
// **`delete providerClosed[provider]`** —— 两回事:
|
|
8482
|
+
// - 「不落」= 不设置;
|
|
8483
|
+
// - `false` = **主动删除**用户已经设好的意图。
|
|
8484
|
+
//
|
|
8485
|
+
// 用户报障的完整链条(实测现场:`providerClosed` 只剩 `{accio:true}`):
|
|
8486
|
+
// ```
|
|
8487
|
+
// ① 点「关闭供应商」 ⇒ providerClosed={X:true} + 全量黑名单 ← 本来稳定
|
|
8488
|
+
// ② 之后在模型列表屏对 X 点一次「全关」 ⇒ 本行传 false ⇒ 意图被删
|
|
8489
|
+
// ③ 插件更新 / 目录变长 ⇒ 派生判据 disabled!==total ⇒ 翻回「启用」
|
|
8490
|
+
// ```
|
|
8491
|
+
// ⇒ 用户看到「关闭过的供应商自己变回启用」,且无任何提示。
|
|
8492
|
+
await pool.writeModelsWithProviderClosed(req.provider, pending, req.closeProvider !== false ? true : 'keep');
|
|
8116
8493
|
ctx.logger.info(`[jet-hub] 关闭 ${req.provider} 的 ${pending.length} 个模型`
|
|
8117
|
-
+ (closeProvider ? '' : '
|
|
8494
|
+
+ (req.closeProvider !== false ? '' : '(不动供应商关闭意图)'));
|
|
8118
8495
|
}
|
|
8119
8496
|
}
|
|
8120
8497
|
else {
|
|
@@ -8204,9 +8581,8 @@ function registerJetHubEndpoints(ctx, pool, auths, modelAdapters) {
|
|
|
8204
8581
|
* ⚠️ 这样**常见路径零网络**:绝大多数供应商是「未关闭」,子集判据
|
|
8205
8582
|
* 直接给 false、不触发核实(冷缓存下也不触发)。只有**真的可能已关闭**
|
|
8206
8583
|
* 的供应商才付一次目录读取;缓存已热时那次读是纯内存的。
|
|
8207
|
-
* ⚠️
|
|
8208
|
-
*
|
|
8209
|
-
* 的最坏值,而实际情况是缓存已热(用户会先看到列表才会去关)。
|
|
8584
|
+
* ⚠️ 代价:**只有真的可能已关闭**的供应商才付一次目录读取;缓存已热时
|
|
8585
|
+
* 那次读是纯内存的。并发后总时长与家数**无关**(见阶段 2 的注释)。
|
|
8210
8586
|
*/
|
|
8211
8587
|
case 'provider.status': {
|
|
8212
8588
|
const req = payload;
|
|
@@ -8214,12 +8590,24 @@ function registerJetHubEndpoints(ctx, pool, auths, modelAdapters) {
|
|
|
8214
8590
|
return { ok: false, error: { code: 'bad-request', message: 'providers 必须是字符串数组' } };
|
|
8215
8591
|
}
|
|
8216
8592
|
const statuses = {};
|
|
8217
|
-
|
|
8218
|
-
|
|
8219
|
-
|
|
8220
|
-
|
|
8221
|
-
|
|
8222
|
-
|
|
8593
|
+
// ⚠️⚠️ **三阶段:先同步算出「谁需要核实」,再并发核实,最后生成状态**
|
|
8594
|
+
//(2026-11-05 三审端到端 P1-1)。原先是一个 `for` 里逐家
|
|
8595
|
+
// `await fullCatalogIds(...)`,而该调用最长 2000ms
|
|
8596
|
+
//(`CATALOG_READ_TIMEOUT_MS`)⇒ 28 家全关时**串行 56194ms**(实测)。
|
|
8597
|
+
// 症状:插件更新/重启后首次打开设置页,供应商开关整片灰显
|
|
8598
|
+
//(`reason: '状态尚未读取'`)最长 50 秒,期间分组不生效、之后突然重排,
|
|
8599
|
+
// **全程零提示**。
|
|
8600
|
+
//
|
|
8601
|
+
// ⚠️ `fullCatalogIds` 是**幂等**的读(只读目录与黑名单,不写本仓库的
|
|
8602
|
+
// 状态、不广播),故并发安全。⚠️ 它**不是**「纯读」——冷缓存下会写
|
|
8603
|
+
// models.dev 的**磁盘缓存**(`src/models-dev-cache.ts` 的
|
|
8604
|
+
// `writeFile` + `rename`)并发网络请求;那份缓存的并发由模块级在途槽
|
|
8605
|
+
// + `RemoteCatalogGate` 去重保证(2026-11-05 四审并发 P1-2 更正:
|
|
8606
|
+
// 原注释自称「纯读」,与实现不符)。
|
|
8607
|
+
// 每家的 2s 预算不变,总时长从 `N × 2s` 降到 `≤ 2s`。
|
|
8608
|
+
// ⚠️ 判据只写一份(`computePlan`):循环与预取共用它,避免两处漂移
|
|
8609
|
+
// (本仓库「一文件两套同义判据」是红线)。
|
|
8610
|
+
const computePlan = (provider) => {
|
|
8223
8611
|
const catalog = modelAdapters?.[provider]?.listAllModels();
|
|
8224
8612
|
let total = catalog?.length ?? 0;
|
|
8225
8613
|
// ⚠️ `listAllModels()` **不带 disabled 字段**,故必须另取黑名单再按 id 计数。
|
|
@@ -8268,10 +8656,146 @@ function registerJetHubEndpoints(ctx, pool, auths, modelAdapters) {
|
|
|
8268
8656
|
closed = true;
|
|
8269
8657
|
disabled = total;
|
|
8270
8658
|
}
|
|
8659
|
+
return { total, disabled, closed, closedByIntent };
|
|
8660
|
+
};
|
|
8661
|
+
// 阶段 2:**并发**核实(只对「派生判据为已关闭且无意图」的家发请求)。
|
|
8662
|
+
// ⚠️ 「空 id 不进结果」:它不可能对应任何 provider,留着只会让前端多一个
|
|
8663
|
+
// 无意义的键(前端按 PROVIDERS 取,多出来的键会被忽略,但脏数据不该产生)。
|
|
8664
|
+
const planMap = new Map();
|
|
8665
|
+
for (const provider of req.providers) {
|
|
8666
|
+
if (provider.length === 0)
|
|
8667
|
+
continue;
|
|
8668
|
+
planMap.set(provider, computePlan(provider));
|
|
8669
|
+
}
|
|
8670
|
+
const verifyMap = new Map();
|
|
8671
|
+
await Promise.all([...planMap]
|
|
8672
|
+
.filter(([, plan]) => plan.closed && !plan.closedByIntent)
|
|
8673
|
+
.map(async ([provider]) => {
|
|
8674
|
+
// ⚠️ 走 single-flight:同一 provider 的在飞核实只发一次请求
|
|
8675
|
+
//(2026-11-05 四审端到端 P2-1,见 `verifyCatalogOnce`)。
|
|
8676
|
+
verifyMap.set(provider, await verifyCatalogOnce(provider));
|
|
8677
|
+
}));
|
|
8678
|
+
// 阶段 3:应用核实结果并生成状态。
|
|
8679
|
+
for (const provider of req.providers) {
|
|
8680
|
+
const plan = planMap.get(provider);
|
|
8681
|
+
if (plan === undefined)
|
|
8682
|
+
continue;
|
|
8683
|
+
let { total, disabled, closed } = plan;
|
|
8684
|
+
/** 核实腿没能证明「已关闭」时的原因(见 `ProviderStatus.verifyFailed`)。 */
|
|
8685
|
+
let verifyFailed;
|
|
8271
8686
|
// ⚠️⚠️ 只有「即将报已关闭」才核实(危险方向,见方法头)。
|
|
8272
8687
|
// ⚠️ 意图为真时**跳过核实**:核实是为了「证明目录里每一条都关着」,
|
|
8273
8688
|
// 而意图已经把整家关掉了 ⇒ 核实既无必要,还会因一次远端抖动
|
|
8274
8689
|
// 把 `closed` 翻回 false(正是本 issue 的形态)。
|
|
8690
|
+
if (closed && !plan.closedByIntent) {
|
|
8691
|
+
// ⚠️ 阶段 2 已按同一判据预取,但**判据写了两份**(那边的 `filter`
|
|
8692
|
+
// 与这里的 `if`)⇒ 将来任何人在阶段 1 加一个 `continue` 就会
|
|
8693
|
+
// 「该核实却没预取」⇒ 这里必须显式处理 `undefined`
|
|
8694
|
+
//(2026-11-05 四审并发 P2-3;改用 `!` 会在下面 `full.notReady`
|
|
8695
|
+
// 处抛 `TypeError`,把一次读状态变成 500)。
|
|
8696
|
+
const full = verifyMap.get(provider);
|
|
8697
|
+
if (full === undefined)
|
|
8698
|
+
continue;
|
|
8699
|
+
// ⚠️⚠️ **判据是「远端读成功」,不是 `complete`**:`complete` 额外要求
|
|
8700
|
+
// 远端**非空**,而这里恰好有一个**正常**的空形态 ——
|
|
8701
|
+
// 「全部模型都已关闭」时 `listModels()` 被黑名单过滤成 `[]`
|
|
8702
|
+
//(实测:这正是本端点要正确回答的那个状态!)。
|
|
8703
|
+
// 若这里用 `complete`,一关全就永远核实不了、`closed` 恒为 false
|
|
8704
|
+
// ⇒ 「关闭供应商」后界面永远显示未关闭(本修复第一版踩过,
|
|
8705
|
+
// 两条既有用例当场变红)。
|
|
8706
|
+
// ⚠️ 而「无账号门控」(真的看不到)时远端也是 `[]`,两者**同形**;
|
|
8707
|
+
// 此时并集只剩适配器兜底表,`disabled` 会按它算 —— 因为
|
|
8708
|
+
// `closed` 的判据是「子集里全部命中」,若兜底表全命中就仍报已关闭。
|
|
8709
|
+
// 这是可接受的:兜底表全关 + 远端看不到 ⇒ 用户确实没有可选模型。
|
|
8710
|
+
if (full.notReady !== undefined) {
|
|
8711
|
+
// ⚠️⚠️ **适配器自报「目录还没读全」⇒ 报安全方向**(Critical)。
|
|
8712
|
+
//
|
|
8713
|
+
// 与 `provider.setEnabled` 同一个根因(`fullCatalogIds` 的第 3 种形态),
|
|
8714
|
+
// 但**用户后果不同**:那边是「只关掉一部分却报成功」,这边是
|
|
8715
|
+
// 「只关掉 `auto`,整个『聚合』在设置页被标成**已关闭**」。
|
|
8716
|
+
// 控制方实测(Task 7 之后):
|
|
8717
|
+
// ```
|
|
8718
|
+
// provider.status = {"total":1,"disabled":1,"closed":true,"verified":"ok(远端 0 条)"}
|
|
8719
|
+
// 改前形态 = {"total":1,"disabled":1,"closed":false,"verified":"remoteError:超时"}
|
|
8720
|
+
// ```
|
|
8721
|
+
// 改后核实「成功」但只见到 `auto` ⇒ `closed=true`(**危险方向**),
|
|
8722
|
+
// 而另外两个虚拟模型仍可选 —— 界面与事实相反。
|
|
8723
|
+
//
|
|
8724
|
+
// ⚠️⚠️ 这一格与下面的 `remoteError` **必须分开**(2026-11-05 四审
|
|
8725
|
+
// 端到端 P1-1 与三审 P1-2 的裁决):
|
|
8726
|
+
// - `notReady` 是**适配器确定性地**说「我这份目录不全」⇒ 此时
|
|
8727
|
+
// 「派生判据说全关」**不构成证据**(它只见到一个子集)⇒ 必须报
|
|
8728
|
+
// `closed:false`。这个判断**不随上游抖动翻转**(它是适配器自己
|
|
8729
|
+
// 的就绪状态),故没有「28 家一起翻」的问题。
|
|
8730
|
+
// - `remoteError` 是**瞬态网络故障**(429 / 502 / 超时)⇒ 本地
|
|
8731
|
+
// 证据(目录快照 + 黑名单)**一个字都没变**,变的只是「远端
|
|
8732
|
+
// 读不到」⇒ 保留派生判据(见下面 else 分支的长注释)。
|
|
8733
|
+
verifyFailed = full.notReady;
|
|
8734
|
+
closed = false;
|
|
8735
|
+
}
|
|
8736
|
+
else if (full.remoteError === undefined) {
|
|
8737
|
+
total = full.ids.length;
|
|
8738
|
+
// ⚠️⚠️ 黑名单必须在**这一刻**重读(2026-11-05 四审并发 P1-1)。
|
|
8739
|
+
//
|
|
8740
|
+
// 原实现用阶段 1 的快照(`plan.disabledMap`),理由是「黑名单与
|
|
8741
|
+
// 目录必须来自同一时刻」。方向对,但**取错了那一时刻**:
|
|
8742
|
+
// 阶段 1 在**所有**核实之前跑完,而 `total` 来自**全部**核实
|
|
8743
|
+
// 之后 ⇒ 窗口从「该家一次读取(≤2s)」**放大**成「阶段 1 剩余
|
|
8744
|
+
// + 全部核实」。可复现(两供应商,p1 核实期间把 m3 移出黑名单):
|
|
8745
|
+
// ```
|
|
8746
|
+
// 改前 p2 = {"total":3,"disabled":2,"closed":false} ✅ 安全
|
|
8747
|
+
// 改后 p2 = {"total":3,"disabled":3,"closed":true} ❌ 报已关闭而
|
|
8748
|
+
// m3 已可选
|
|
8749
|
+
// ```
|
|
8750
|
+
// 现在两者紧挨着取 ⇒ 窗口 = 两次同步调用之间的**零 await**。
|
|
8751
|
+
const disabledMap = pool.listDisabledModels(provider);
|
|
8752
|
+
disabled = full.ids.filter((id) => disabledMap[id] === true).length;
|
|
8753
|
+
closed = total > 0 && disabled === total;
|
|
8754
|
+
}
|
|
8755
|
+
else {
|
|
8756
|
+
// ⚠️⚠️⚠️ **瞬态远端故障时绝不改写 `closed`**(2026-11-05 四审端到端 P1-1)。
|
|
8757
|
+
//
|
|
8758
|
+
// 三审(`9b2f93a`)这里原本是 `closed = false`,理由是「保守报
|
|
8759
|
+
// 未关闭是安全方向」。**该结论已被真实链路实测推翻**:
|
|
8760
|
+
//
|
|
8761
|
+
// 真实 UI 载荷是 `model.setAllDisabled({closeProvider:false})`
|
|
8762
|
+
//(`plugin-src/client/jet-hub.js:7757-7761`)⇒ **永不写关闭意图**
|
|
8763
|
+
// ⇒ 每次读状态都走核实腿。于是**任何一次上游瞬态故障**
|
|
8764
|
+
//(429 / 502 / 超时 > 2s)都会把「派生判据说已关闭」的**全部**
|
|
8765
|
+
// 供应商一起翻成 `closed:false`。实测 28 家同时关闭:
|
|
8766
|
+
// ```
|
|
8767
|
+
// 健康目录: closed===true = 28/28
|
|
8768
|
+
// 目录 429(2ms): closed===false = 28/28 ← 界面「全部开启」
|
|
8769
|
+
// 502 / 超时 2100ms:同上
|
|
8770
|
+
// ```
|
|
8771
|
+
// 而 `groupProviders`(`plugin-src/client/provider-toggle.js:42-55`)
|
|
8772
|
+
// 只读 `closed === true` ⇒ 28 家整片从「已关闭」组跳到「已打开」组
|
|
8773
|
+
// = 用户报障的「有时候全部开启 / 全部关闭」。
|
|
8774
|
+
//
|
|
8775
|
+
// ⇒ 正确语义:**「核实不了」只意味着「我无法证明它已关闭」,
|
|
8776
|
+
// 不意味着「它没关闭」**。此时保留派生判据的结论(`closed` 与
|
|
8777
|
+
// `disabled`/`total` 都来自**同一个**本地快照,三者自洽),
|
|
8778
|
+
// 只用 `verifyFailed` 附注「本次未能核实」。
|
|
8779
|
+
//
|
|
8780
|
+
// ⚠️ 保留 `closed:true` 会不会「危险」(界面说已关闭而模型可选)?
|
|
8781
|
+
// 本格的触发条件是**远端读失败**,而目录快照与黑名单一个字都没变
|
|
8782
|
+
// ⇒ 若目录真的变长了,那一次**成功**的核实会给出 `closed:false`
|
|
8783
|
+
//(见上面 `total = full.ids.length` 那一支)。即:只有「读到了
|
|
8784
|
+
// 新目录」才允许改判 —— 与 `notReady` 那一格刻意不同。
|
|
8785
|
+
//
|
|
8786
|
+
// ⚠️⚠️ **前端在这一格**拿不到**原因**(2026-11-05 对抗审计 P2-3):
|
|
8787
|
+
// `providerSwitchState` 的第一条 `if (status.closed === true)`
|
|
8788
|
+
// **先短路** ⇒ 本格 `closed:true` + `verifyFailed` ⇒ 前端渲染成
|
|
8789
|
+
// 「已关闭、可点开」,**`reason` 为 null** ⇒ 悬停看不到「本次没核实成」。
|
|
8790
|
+
// (`notReady` 那一格不同:它报 `closed:false` ⇒ 走下面那条
|
|
8791
|
+
// 「核实失败 ⇒ 禁用 + 原因」分支 ⇒ 原因可见。)
|
|
8792
|
+
// ⇒ 这里**刻意**保留 `closed:true`(界面与分组自洽,见上方注释),
|
|
8793
|
+
// `verifyFailed` 只作**排障线索**(服务端日志 / 客户端 console),
|
|
8794
|
+
// **不得**在注释里承诺「前端会渲染成禁用 + 原因」——
|
|
8795
|
+
// 那会是一个不存在的渲染。
|
|
8796
|
+
verifyFailed = full.remoteError;
|
|
8797
|
+
}
|
|
8798
|
+
}
|
|
8275
8799
|
const entries = pool.listAccountsByProvider(provider);
|
|
8276
8800
|
// ⚠️ 目录健康快照是**可选诊断**(issue IKKZUG 第 5 点):
|
|
8277
8801
|
// 只有目录来自多个外部来源的适配器实现它(目前只有 cline)。
|
|
@@ -8286,11 +8810,6 @@ function registerJetHubEndpoints(ctx, pool, auths, modelAdapters) {
|
|
|
8286
8810
|
catch {
|
|
8287
8811
|
catalogHealth = undefined;
|
|
8288
8812
|
}
|
|
8289
|
-
if (closed && !closedByIntent) {
|
|
8290
|
-
// 需要核实:先记下现场,结果在下面第二轮统一并入 `statuses`。
|
|
8291
|
-
verifications.push({ provider, disabledMap, total, disabled, entries, catalogHealth });
|
|
8292
|
-
continue;
|
|
8293
|
-
}
|
|
8294
8813
|
statuses[provider] = {
|
|
8295
8814
|
models: { total, disabled },
|
|
8296
8815
|
accounts: {
|
|
@@ -8301,71 +8820,11 @@ function registerJetHubEndpoints(ctx, pool, auths, modelAdapters) {
|
|
|
8301
8820
|
},
|
|
8302
8821
|
closed,
|
|
8303
8822
|
...catalogHealth === undefined ? {} : { catalog: catalogHealth },
|
|
8823
|
+
// ⚠️ 字段**缺席**表示「核实成功或未需要核实」;只有「派生判据说已关闭、
|
|
8824
|
+
// 但核实腿没能证明」时才出现(见 `ProviderStatus.verifyFailed`)。
|
|
8825
|
+
...verifyFailed === undefined ? {} : { verifyFailed },
|
|
8304
8826
|
};
|
|
8305
8827
|
}
|
|
8306
|
-
// ── 第二遍:**共用一轮预算**并发核实 ──
|
|
8307
|
-
// ⚠️ 单家 `fullCatalogIds` 自带 {@link CATALOG_READ_TIMEOUT_MS} 超时;
|
|
8308
|
-
// 同一轮启动的多个核实时间窗重叠 ⇒ 无论几家,整体最坏 ≈ 2 秒
|
|
8309
|
-
// (而不是串行的 N × 2 秒)。预算耗尽时该家的 `fullCatalogIds`
|
|
8310
|
-
// 以 `remoteError` 落地,走既有的「保守报未关闭」降级 —— 语义与
|
|
8311
|
-
// 串行版逐字一致,只是等待不再相加。
|
|
8312
|
-
await Promise.all(verifications.map(async (pending) => {
|
|
8313
|
-
const full = await fullCatalogIds(ctx, modelAdapters, pending.provider);
|
|
8314
|
-
// ⚠️⚠️ **判据是「远端读成功」,不是 `complete`**:`complete` 额外要求
|
|
8315
|
-
// 远端**非空**,而这里恰好有一个**正常**的空形态 ——
|
|
8316
|
-
// 「全部模型都已关闭」时 `listModels()` 被黑名单过滤成 `[]`
|
|
8317
|
-
//(实测:这正是本端点要正确回答的那个状态!)。
|
|
8318
|
-
// 若这里用 `complete`,一关全就永远核实不了、`closed` 恒为 false
|
|
8319
|
-
// ⇒ 「关闭供应商」后界面永远显示未关闭(本修复第一版踩过,
|
|
8320
|
-
// 两条既有用例当场变红)。
|
|
8321
|
-
// ⚠️ 而「无账号门控」(真的看不到)时远端也是 `[]`,两者**同形**;
|
|
8322
|
-
// 此时并集只剩适配器兜底表,`disabled` 会按它算 —— 因为
|
|
8323
|
-
// `closed` 的判据是「子集里全部命中」,若兜底表全命中就仍报已关闭。
|
|
8324
|
-
// 这是可接受的:兜底表全关 + 远端看不到 ⇒ 用户确实没有可选模型。
|
|
8325
|
-
let total = pending.total;
|
|
8326
|
-
let disabled = pending.disabled;
|
|
8327
|
-
let closed = true;
|
|
8328
|
-
if (full.notReady !== undefined) {
|
|
8329
|
-
// ⚠️⚠️ **适配器自报「目录还没读全」⇒ 报安全方向**(Critical)。
|
|
8330
|
-
//
|
|
8331
|
-
// 与 `provider.setEnabled` 同一个根因(`fullCatalogIds` 的第 3 种形态),
|
|
8332
|
-
// 但**用户后果不同**:那边是「只关掉一部分却报成功」,这边是
|
|
8333
|
-
// 「只关掉 `auto`,整个『聚合』在设置页被标成**已关闭**」。
|
|
8334
|
-
// 控制方实测(Task 7 之后):
|
|
8335
|
-
// ```
|
|
8336
|
-
// provider.status = {"total":1,"disabled":1,"closed":true,"verified":"ok(远端 0 条)"}
|
|
8337
|
-
// 改前形态 = {"total":1,"disabled":1,"closed":false,"verified":"remoteError:超时"}
|
|
8338
|
-
// ```
|
|
8339
|
-
// 改前该路径必然 2000ms 超时 ⇒ `remoteError` ⇒ `closed=false`(**安全方向**);
|
|
8340
|
-
// 改后核实「成功」但只见到 `auto` ⇒ `closed=true`(**危险方向**),
|
|
8341
|
-
// 而另外两个虚拟模型仍可选 —— 界面与事实相反。
|
|
8342
|
-
//
|
|
8343
|
-
// ⇒ 这里把 `notReady` 与「核实不了(远端读失败)」**并列**处理:
|
|
8344
|
-
// 两者都说明「我这份合并目录不足以证明已关闭」,都报 `closed:false`。
|
|
8345
|
-
// 报 false 是安全的(用户可再点一次开关,点了会得到上面那条明确拒绝)。
|
|
8346
|
-
closed = false;
|
|
8347
|
-
}
|
|
8348
|
-
else if (full.remoteError === undefined) {
|
|
8349
|
-
total = full.ids.length;
|
|
8350
|
-
disabled = full.ids.filter((id) => pending.disabledMap[id] === true).length;
|
|
8351
|
-
closed = total > 0 && disabled === total;
|
|
8352
|
-
}
|
|
8353
|
-
else {
|
|
8354
|
-
// 核实不了(远端读失败)⇒ 保守报未关闭(安全方向)。
|
|
8355
|
-
closed = false;
|
|
8356
|
-
}
|
|
8357
|
-
statuses[pending.provider] = {
|
|
8358
|
-
models: { total, disabled },
|
|
8359
|
-
accounts: {
|
|
8360
|
-
total: pending.entries.length,
|
|
8361
|
-
// 与适配器一致的判据:`enabled !== false` 视为启用
|
|
8362
|
-
//(老文档可能缺该字段,缺省语义等同启用)。
|
|
8363
|
-
enabled: pending.entries.filter((entry) => entry.enabled !== false).length,
|
|
8364
|
-
},
|
|
8365
|
-
closed,
|
|
8366
|
-
...pending.catalogHealth === undefined ? {} : { catalog: pending.catalogHealth },
|
|
8367
|
-
};
|
|
8368
|
-
}));
|
|
8369
8828
|
const value = { statuses };
|
|
8370
8829
|
return { ok: true, value };
|
|
8371
8830
|
}
|
|
@@ -8548,7 +9007,7 @@ function registerJetHubEndpoints(ctx, pool, auths, modelAdapters) {
|
|
|
8548
9007
|
// 否则对话框的模型选择器要重启才更新(成因见 broadcastCatalogChanged)。
|
|
8549
9008
|
broadcastCatalogChanged(ctx);
|
|
8550
9009
|
ctx.logger.info(`[jet-hub] ${req.enabled ? '打开' : '关闭'}供应商 ${req.provider}:`
|
|
8551
|
-
+ `${req.enabled ? '清空' : '
|
|
9010
|
+
+ `${req.enabled ? '清空' : '变更'} ${modelCount} 个模型、`
|
|
8552
9011
|
+ `${req.enabled ? '启用' : '停用'} ${accountCount} 个账号`);
|
|
8553
9012
|
const value = {
|
|
8554
9013
|
provider: req.provider,
|