@angelyeye/dsh-cost-tracker 1.8.15 → 1.9.2

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/pricing.js CHANGED
@@ -3,18 +3,26 @@
3
3
  //
4
4
  // 单价来源:DeepSeek 官方定价页
5
5
  // https://api-docs.deepseek.com/zh-cn/quick_start/pricing
6
- // - 高峰时段(北京时间周一至周五 9:00-12:00、14:00-18:00)为表内价格;
7
- // 空闲时段 = 高峰 × 0.5。周末(周六/周日)全天计入空闲时段(该窗口两版价通用)。
6
+ // - 高峰时段(北京时间周一至周五 9:00-12:00、14:00-18:00,**不含中国法定节假日**)
7
+ // 为表内价格;其余时段(含周末与法定节假日全天)= 高峰 × 0.5。
8
8
  // - **单价随时间调整**:故单价表按生效时刻分版(见 PRICE_ERAS),按记录时间戳选版。
9
9
  // · legacy :V4-Flash 3.0/9.0/0.10、V4-Pro 9.0/27.0/0.30
10
10
  // · v41 :V4.1 Flash 2.0/8.0/0.04(北京时间 2026-09-10 12:00 起生效)。
11
11
  // 官方现役模型名为 `deepseek-flash`;旧名 `deepseek-v4-flash` 与
12
12
  // `deepseek-v4-flash-vision-exp` 已下线但仍可调用,请求由 V4.1 Flash
13
13
  // 提供服务并按 Flash 价计费,故一并路由到 `deepseek-flash`。
14
- // · v41pro :同一档单价,**V4-Pro 路由在此才开始**:官方通告为「北京时间 2026-09-14
15
- // 12:00 之后,deepseek-v4-pro 的请求全部路由到 V4.1 Flash 并按 V4.1 Flash
16
- // 单价计费」(价格卡脚注 (2) 同口径)。9/10 12:00 ~ 9/14 12:00 之间的
17
- // V4-Pro 请求按 V4-Pro 自有牌价 9.0/27.0/0.30 计费,不可提前折算。
14
+ // **V4-Pro 维持自有牌价(9.0/27.0/0.30),不做任何路由**:
15
+ // 09-10 新闻稿确实预告过「9-14 12:00 之后 pro 请求全部路由到 V4.1 Flash
16
+ // 并按 Flash 单价计费」,v1.9.0/1.9.1 据此实现了 v41pro 时代;但官方
17
+ // **更新日志随后改为**「为响应广大用户的需求,我们决定在 2026 年 9 月 14 日
18
+ // 之后继续提供 DeepSeek V4 Pro 的 API 调用服务,计费方式保持不变」,
19
+ // 且现行价目页仍为 pro **单列价格**(9.0/27.0/0.30)与**独立并发 500**
20
+ // (flash 为 2500),脚注只把旧 flash 名与 `deepseek-v4.1-flash` 路由到
21
+ // flash。故 v1.9.2 起**取消 pro 的反向路由**:否则会按 Flash 价计 pro 调用
22
+ // (输入 2 vs 9、输出 8 vs 27),显著低估。
23
+ // - 法定节假日(isPeak / peakPhaseAt 的 offAllDay):官方口径把节假日全天计入空闲时段,
24
+ // 数据来自国务院办公厅节假日安排通知(见 CN_HOLIDAYS)。调休补班的周六/周日**不**计高峰
25
+ // —— 定价规则只看「周一至周五」,调休不改变这一点。
18
26
  // - deepseek-v4-flash-vision-exp 与 deepseek-v4-flash 在 legacy 时代单价一致。
19
27
  // - 模型名归一化后 `deepseek-v4.1-flash` 等同为 `deepseek-flash` 的等价写法,命中同一档。
20
28
  //
@@ -43,14 +51,6 @@
43
51
  /** V4.1 Flash 价格的生效时刻:北京时间 2026-09-10 12:00(UTC+8)= 2026-09-10T04:00:00Z */
44
52
  export const V41_EFFECTIVE_AT = Date.UTC(2026, 8, 10, 4, 0, 0)
45
53
 
46
- /**
47
- * V4-Pro 请求被路由到 V4.1 Flash 的生效时刻:北京时间 2026-09-14 12:00。
48
- * 官方表述:「北京时间 2026 年 9 月 14 日 12:00 之后,至未来 V4.1 Pro 上线之前,
49
- * 用户访问 deepseek-v4-pro 的请求将全部路由到 V4.1 Flash,并按 V4.1 Flash 单价计费」。
50
- * 注意它与 V41_EFFECTIVE_AT(9-10 12:00)不是同一时刻,提前折算会低估 V4-Pro 花费。
51
- */
52
- export const V41_PRO_ROUTE_AT = Date.UTC(2026, 8, 14, 4, 0, 0)
53
-
54
54
  /**
55
55
  * V4.1 Flash 档的规范(官方现役)模型名。
56
56
  * 官方文档:「模型名请使用 `deepseek-flash`」——被路由的请求一律以此名入账,
@@ -72,33 +72,17 @@ export const PRICE_ERAS = [
72
72
  },
73
73
  {
74
74
  id: 'v41',
75
- label: 'V4.1 Flash 价(2026-09-10 12:00 起;V4-Pro 此时仍按自有牌价)',
75
+ label: 'V4.1 Flash 价(2026-09-10 12:00 起;V4-Pro 维持自有牌价)',
76
76
  since: V41_EFFECTIVE_AT,
77
77
  models: {
78
78
  // 高峰价:输入(缓存命中)0.04 / 输入(缓存未命中)2 / 输出 8;空闲减半
79
79
  [V41_FLASH_MODEL]: { input: 2.0, output: 8.0, cacheRead: 0.04, cacheWrite: 0.04 },
80
- // V4-Pro 尚在「自有牌价」窗口(9-14 12:00 前不路由),故本时代仍需保留其单价,
81
- // 否则会落入 provider 兜底而被误标记为「估算」。
80
+ // V4-Pro 维持自有牌价:官方 9-14 撤销了下线计划(「继续提供服务,计费方式保持不变」),
81
+ // 现行价目页仍为其单列 9.0/27.0/0.30 与独立并发 500 —— 因此**不做路由**。
82
82
  'deepseek-v4-pro': { input: 9.0, output: 27.0, cacheRead: 0.30, cacheWrite: 0.30 },
83
83
  },
84
84
  // 旧 V4-Flash 系(含视觉版)已下线,请求由 V4.1 Flash 提供并按 Flash 价计费。
85
- // V4-Pro 此时尚未路由(官方路由时刻为 9-14 12:00,见下一个时代)。
86
- routes: {
87
- 'deepseek-v4-flash': V41_FLASH_MODEL,
88
- 'deepseek-v4-flash-vision-exp': V41_FLASH_MODEL,
89
- },
90
- proRouteSince: V41_PRO_ROUTE_AT,
91
- },
92
- {
93
- id: 'v41pro',
94
- label: 'V4.1 Flash 价 + V4-Pro 路由(2026-09-14 12:00 起)',
95
- since: V41_PRO_ROUTE_AT,
96
- models: {
97
- [V41_FLASH_MODEL]: { input: 2.0, output: 8.0, cacheRead: 0.04, cacheWrite: 0.04 },
98
- },
99
- // V4.1 Pro 上线前,V4-Pro 的请求全部路由到 V4.1 Flash 并按 V4.1 Flash 单价计费。
100
85
  routes: {
101
- 'deepseek-v4-pro': V41_FLASH_MODEL,
102
86
  'deepseek-v4-flash': V41_FLASH_MODEL,
103
87
  'deepseek-v4-flash-vision-exp': V41_FLASH_MODEL,
104
88
  },
@@ -157,14 +141,66 @@ export function resolveModelInEra(era, model) {
157
141
  return null
158
142
  }
159
143
 
160
- /** 某一时刻生效的价格时代(缺省用当前时间)。 */
144
+ /** 某一时刻生效的价格时代(缺省用当前时间)。
145
+ * v1.9.0 起:在内置 PRICE_ERAS 之外合并**官方同步时代**(setSyncedEras 注入,
146
+ * 见 price-sync.js)——两侧按 since 取「最近生效者」,同时刻同步时代优先
147
+ * (同步数据来自官方页面实抓,比内置常量新)。 */
161
148
  export function eraAt(ts) {
162
149
  const t = Number.isFinite(ts) ? ts : Date.now()
163
150
  let cur = PRICE_ERAS[0]
164
151
  for (const e of PRICE_ERAS) if (t >= e.since) cur = e
152
+ for (const e of SYNCED_ERAS) {
153
+ if (t >= e.since && (cur === PRICE_ERAS[0] || e.since >= cur.since)) cur = e
154
+ }
165
155
  return cur
166
156
  }
167
157
 
158
+ // ---------- 官方同步时代(v1.9.0,price-sync.js 注入) ----------
159
+ let SYNCED_ERAS = []
160
+ /**
161
+ * 注入官方价格同步产生的时代(启动时从 storages/cost-tracker-prices.json 加载)。
162
+ * 时代按 since 升序排序;非法条目(缺 models/since)丢弃,绝不阻断启动。
163
+ * @param {object[]} eras
164
+ */
165
+ export function setSyncedEras(eras) {
166
+ SYNCED_ERAS = (Array.isArray(eras) ? eras : [])
167
+ .filter((e) => e && typeof e === 'object' && Number.isFinite(e.since) && e.models && typeof e.models === 'object')
168
+ .sort((a, b) => a.since - b.since)
169
+ .map((e) => Object.assign({ routes: {}, label: '官方同步价', synced: true }, e))
170
+ }
171
+ /** 当前注入的同步时代(只读副本,供状态回显) */
172
+ export function getSyncedEras() { return SYNCED_ERAS.slice() }
173
+
174
+ // ---------- 手动覆盖价(v1.9.0,插件配置卡维护) ----------
175
+ let PRICE_OVERRIDES = new Map()
176
+ function overrideKey(np, model) {
177
+ return normalizeModelName(np) + '/' + normalizeModelName(model)
178
+ }
179
+ /**
180
+ * 注入手动覆盖价:键 'provider/model'(两侧都归一化),值为
181
+ * {input, output, cacheRead, cacheWrite}(CNY / 1M tokens)。
182
+ * 命中优先级最高(高于订阅归类、同步时代与目录)。
183
+ */
184
+ export function setPriceOverrides(map) {
185
+ PRICE_OVERRIDES = new Map()
186
+ for (const [k, v] of Object.entries(map && typeof map === 'object' ? map : {})) {
187
+ if (!v || typeof v !== 'object') continue
188
+ const rates = {
189
+ input: Number(v.input), output: Number(v.output),
190
+ cacheRead: Number(v.cacheRead), cacheWrite: Number(v.cacheWrite === undefined ? v.cacheRead : v.cacheWrite),
191
+ }
192
+ if (!rates.input || !Number.isFinite(rates.input) || rates.input < 0) continue
193
+ if (!Number.isFinite(rates.output) || rates.output < 0) continue
194
+ if (!Number.isFinite(rates.cacheRead) || rates.cacheRead < 0) continue
195
+ // 键形如 'provider/model':先按 '/' 拆开再各自归一化(normalizeModelName 会
196
+ // 剔除一切非字母数字,直接整串归一会把 '/' 吃掉,导致写读两侧对不上)
197
+ const parts = String(k).split('/')
198
+ if (parts.length !== 2 || !parts[0].trim() || !parts[1].trim()) continue
199
+ PRICE_OVERRIDES.set(normalizeModelName(parts[0]) + '/' + normalizeModelName(parts[1]), { rates, tiered: false })
200
+ }
201
+ }
202
+ export function getPriceOverrides() { return PRICE_OVERRIDES }
203
+
168
204
  /** 某一时刻生效的精确单价表(缺省用当前时间)。 */
169
205
  export function exactModelsAt(ts) { return eraAt(ts).models }
170
206
 
@@ -351,8 +387,8 @@ export const PROVIDER_RATES = {
351
387
  /** 未知模型兜底单价(估算);缓存写入按缓存命中价计。 */
352
388
  export const GENERIC_RATES = { input: 2.0, output: 8.0, cacheRead: 0.5, cacheWrite: 0.5 }
353
389
 
354
- /** 高峰时段(北京时间,仅周一至周五),空闲时段 = 高峰 × 0.5;周末全天空闲 */
355
- export const PEAK_WINDOWS = '周一至周五 9:00-12:00 · 14:00-18:00(周末全天闲时)'
390
+ /** 高峰时段(北京时间,仅周一至周五且非法定节假日),空闲时段 = 高峰 × 0.5 */
391
+ export const PEAK_WINDOWS = '周一至周五 9:00-12:00 · 14:00-18:00(周末与法定节假日全天闲时)'
356
392
 
357
393
  /** 视觉模型名(DeepSeek DeepSeek-V4-Flash-Vision-Exp) */
358
394
  export const VISION_MODEL = 'deepseek-v4-flash-vision-exp'
@@ -360,11 +396,133 @@ export const VISION_MODEL = 'deepseek-v4-flash-vision-exp'
360
396
  /** 每张图片换算 token 的上限(官方规则) */
361
397
  export const VISION_IMAGE_MAX_TOKENS = 384
362
398
 
363
- /** 是否高峰时段(北京时间 UTC+8,仅周一至周五;周末全天空闲) */
399
+ // ------------------------------------------------------------
400
+ // 中国法定节假日(官方峰谷口径:节假日全天计入空闲时段)
401
+ //
402
+ // 官方价目页脚注:「北京时间周一至周五(**不含中国法定节假日**)9:00-12:00、
403
+ // 14:00-18:00 为高峰时段;其余时段,包括周末及中国法定节假日全天均为空闲时段。」
404
+ // 因此仅排除周末是不够的:节假日落在一周内时,峰段也必须按闲时计(否则会多计 1 倍)。
405
+ //
406
+ // 数据来源:国务院办公厅关于节假日安排的通知。
407
+ // · 2026 年:国办发明电〔2025〕7 号(2025-11-04 发布)
408
+ // https://www.gov.cn/zhengce/zhengceku/202511/content_7047091.htm
409
+ // 调休补班的周六/周日**不计高峰**:定价规则只看「周一至周五」,调休不改变这一点。
410
+ // 新一年度的安排通常在上一年 11 月公布,届时更新本表并随版本发布;也可在插件配置卡
411
+ // 用 `peakHolidays` 覆盖(见 setPeakHolidays)。
412
+ // ------------------------------------------------------------
413
+ export const CN_HOLIDAYS = [
414
+ // 2026 · 元旦 1/1-1/3
415
+ '2026-01-01', '2026-01-02', '2026-01-03',
416
+ // 2026 · 春节 2/15-2/23
417
+ '2026-02-15', '2026-02-16', '2026-02-17', '2026-02-18', '2026-02-19',
418
+ '2026-02-20', '2026-02-21', '2026-02-22', '2026-02-23',
419
+ // 2026 · 清明 4/4-4/6
420
+ '2026-04-04', '2026-04-05', '2026-04-06',
421
+ // 2026 · 劳动节 5/1-5/5
422
+ '2026-05-01', '2026-05-02', '2026-05-03', '2026-05-04', '2026-05-05',
423
+ // 2026 · 端午 6/19-6/21
424
+ '2026-06-19', '2026-06-20', '2026-06-21',
425
+ // 2026 · 中秋 9/25-9/27
426
+ '2026-09-25', '2026-09-26', '2026-09-27',
427
+ // 2026 · 国庆 10/1-10/7
428
+ '2026-10-01', '2026-10-02', '2026-10-03', '2026-10-04',
429
+ '2026-10-05', '2026-10-06', '2026-10-07',
430
+ ]
431
+
432
+ /** 把 'YYYY-MM-DD' / 'YYYY/M/D' 归一为 'YYYY-MM-DD';非法返回 '' */
433
+ function normHolidayKey(s) {
434
+ const m = /^(\d{4})[-/.](\d{1,2})[-/.](\d{1,2})$/.exec(String(s == null ? '' : s).trim())
435
+ if (!m) return ''
436
+ const mm = Number(m[2])
437
+ const dd = Number(m[3])
438
+ if (!(mm >= 1 && mm <= 12) || !(dd >= 1 && dd <= 31)) return ''
439
+ return m[1] + '-' + (mm < 10 ? '0' + mm : String(mm)) + '-' + (dd < 10 ? '0' + dd : String(dd))
440
+ }
441
+
442
+ /** 归一化节假日列表:接受数组或「逗号/分号/空白分隔」的整串,去重并升序 */
443
+ export function normalizeHolidayList(input) {
444
+ const out = []
445
+ if (Array.isArray(input)) {
446
+ for (const s of input) { const k = normHolidayKey(s); if (k) out.push(k) }
447
+ } else if (typeof input === 'string') {
448
+ for (const s of input.split(/[\s,,;;]+/)) { const k = normHolidayKey(s); if (k) out.push(k) }
449
+ }
450
+ return Array.from(new Set(out)).sort()
451
+ }
452
+
453
+ // null = 使用内置表 CN_HOLIDAYS;[] = 显式停用(不排除任何节假日);否则为用户覆盖列表
454
+ let PEAK_HOLIDAY_LIST = null
455
+ let PEAK_HOLIDAY_SET = null // Set<string>(null 时按需从 CN_HOLIDAYS 构建)
456
+
457
+ /**
458
+ * 覆盖法定节假日列表(插件配置卡的「峰谷计价与提示」)。语义防呆:
459
+ * · 传 null / undefined / '' → 恢复内置表(默认);config 里存空串即走这条;
460
+ * · 传 'none' / 'off' / '0' → 显式停用(不排除任何节假日,等价于按「仅周末」计);
461
+ * · 传数组或分隔字符串 → 用该列表**整体替换**内置表(不追加);
462
+ * · 传了内容但一条都解析不出 → 视为停用并记入 invalid,如实回显,
463
+ * 避免「以为关掉了节假日,其实还在用内置表」。
464
+ * @returns {{dates:string[], mode:'builtin'|'custom'|'disabled', builtin:boolean, disabled:boolean, count:number, invalid:string[]}}
465
+ */
466
+ export function setPeakHolidays(input) {
467
+ if (Array.isArray(input)) {
468
+ PEAK_HOLIDAY_LIST = normalizeHolidayList(input)
469
+ } else if (input === null || input === undefined) {
470
+ PEAK_HOLIDAY_LIST = null
471
+ } else {
472
+ const raw = String(input).trim()
473
+ if (raw === '') PEAK_HOLIDAY_LIST = null
474
+ else if (/^(none|off|0|无|关|关闭)$/i.test(raw)) PEAK_HOLIDAY_LIST = []
475
+ else PEAK_HOLIDAY_LIST = normalizeHolidayList(raw)
476
+ }
477
+ PEAK_HOLIDAY_SET = null
478
+ return getPeakHolidays(typeof input === 'string' ? input : undefined)
479
+ }
480
+
481
+ /**
482
+ * 当前生效的节假日列表(含来源标记,便于配置卡回显与双端比对)。
483
+ * @param {string} [rawInput] - 可选:原始配置字符串(用于统计被忽略的非法条目)
484
+ */
485
+ export function getPeakHolidays(rawInput) {
486
+ const list = PEAK_HOLIDAY_LIST === null ? CN_HOLIDAYS : PEAK_HOLIDAY_LIST
487
+ const invalid = []
488
+ if (typeof rawInput === 'string' && rawInput.trim() !== '' && !/^(none|off|0|无|关|关闭)$/i.test(rawInput.trim())) {
489
+ for (const tok of rawInput.split(/[\s,,;;]+/)) {
490
+ if (tok && !normHolidayKey(tok)) invalid.push(tok)
491
+ }
492
+ }
493
+ const mode = PEAK_HOLIDAY_LIST === null ? 'builtin' : (PEAK_HOLIDAY_LIST.length === 0 ? 'disabled' : 'custom')
494
+ return { dates: list.slice(), mode, builtin: mode === 'builtin', disabled: mode === 'disabled', count: list.length, invalid }
495
+ }
496
+
497
+ /** 某时刻所属的北京日历日('YYYY-MM-DD') */
498
+ export function holidayKeyAt(ts) {
499
+ const t = Number(ts)
500
+ if (!Number.isFinite(t)) return ''
501
+ const d = new Date(t + 28800000)
502
+ const p = (n) => (n < 10 ? '0' + n : String(n))
503
+ return d.getUTCFullYear() + '-' + p(d.getUTCMonth() + 1) + '-' + p(d.getUTCDate())
504
+ }
505
+
506
+ /** 北京日 index(D0,北京午夜为界)→ 'YYYY-MM-DD' */
507
+ function holidayKeyOfDayIndex(D) {
508
+ return holidayKeyAt(D * 86400000 - 28800000 + 43200000) // 该北京日正午,避免边界歧义
509
+ }
510
+
511
+ /** 某时刻是否落在(配置生效的)中国法定节假日 */
512
+ export function isCnHoliday(ts) {
513
+ const key = holidayKeyAt(ts)
514
+ if (!key) return false
515
+ const set = PEAK_HOLIDAY_SET || (PEAK_HOLIDAY_SET = new Set(PEAK_HOLIDAY_LIST === null ? CN_HOLIDAYS : PEAK_HOLIDAY_LIST))
516
+ return set.has(key)
517
+ }
518
+
519
+ /** 是否高峰时段(北京时间 UTC+8:周一至周五、非节假日、落在峰窗口内) */
364
520
  export function isPeak(ts) {
365
- const d = new Date(ts + 28800000)
521
+ const t = Number(ts)
522
+ const d = new Date(t + 28800000)
366
523
  const day = d.getUTCDay() // 0=周日 … 6=周六
367
524
  if (day === 0 || day === 6) return false // 周末不计高峰
525
+ if (isCnHoliday(t)) return false // 法定节假日全天闲时
368
526
  const h = d.getUTCHours()
369
527
  return (h >= 9 && h < 12) || (h >= 14 && h < 18)
370
528
  }
@@ -374,31 +532,42 @@ export const PEAK_HOUR_WINDOWS = [{ start: 9, end: 12 }, { start: 14, end: 18 }]
374
532
 
375
533
  /**
376
534
  * 某一时刻所处的峰谷相位与相邻切换点(供时段条 / 倒计时 / 切换前弹窗)。
377
- * 与 isPeak 同口径(北京时间 UTC+8),并处理「周末全天谷价」:
378
- * - 工作日:按峰窗口判定 inPeak,扫描前后 N 天收集切换点;
379
- * - 周末:inPeak=false 且 weekend=true,日内无切换点(价格恒为谷),
380
- * 下一个价格切换点为下周一 09:00(首个峰窗口起点)。
535
+ * 与 isPeak 同口径(北京时间 UTC+8),并处理「全天谷价日」:
536
+ * - 普通工作日:按峰窗口判定 inPeak,扫描前后 N 天收集切换点;
537
+ * - 周末 / 法定节假日:inPeak=false、allDayOff=true,日内无切换点(价格恒为谷),
538
+ * 下一个价格切换点为下一个「工作日且非节假日」的首个峰窗口起点;
539
+ * weekend / holiday 分别标记具体原因(节假日落在周末时 weekend 优先)。
381
540
  * @param {number} ts - epoch ms
382
- * @param {number} [spanDays=5] - 前后扫描天数(须覆盖最长周末间隔)
383
- * @returns {{inPeak:boolean, weekend:boolean, prevAtMs:number, nextAtMs:number,
384
- * nextIntoPeak:boolean}|null} prevAtMs/nextAtMs 为相邻切换点 epoch ms
541
+ * @param {number} [spanDays=5] - 前后扫描天数(须覆盖最长连休:春节 9 天,故内部下限取 12)
542
+ * @returns {{inPeak:boolean, weekend:boolean, holiday:boolean, allDayOff:boolean,
543
+ * prevAtMs:number, nextAtMs:number, nextIntoPeak:boolean}|null}
544
+ * prevAtMs/nextAtMs 为相邻切换点 epoch ms(全天谷价日的 prevAtMs = 本段连休起点)
385
545
  */
386
546
  export function peakPhaseAt(ts, spanDays) {
387
547
  if (!Number.isFinite(ts)) return null
388
- const SPAN = (Number.isFinite(spanDays) && spanDays >= 1) ? Math.floor(spanDays) : 5
548
+ // 连休最长可达 9 天(春节),默认扫描窗口必须比它大,否则会找不到下一切换点。
549
+ const SPAN = Math.max(12, (Number.isFinite(spanDays) && spanDays >= 1) ? Math.floor(spanDays) : 5)
389
550
  const DAY_MS = 86400000
390
551
  // 北京时间日 index 与星期(0=周日 … 6=周六;1970-01-01 为周四)。
391
552
  const D0 = Math.floor((ts + 28800000) / DAY_MS)
392
553
  const weekday = (D0 + 4) % 7
393
554
  const isWeekendNow = weekday === 6 || weekday === 0
555
+ const isHolidayNow = isCnHoliday(ts)
556
+ const allDayOffNow = isWeekendNow || isHolidayNow
394
557
  // 某北京时间日 D 的某时 h 对应的 epoch ms(北京 = UTC+8)。
395
558
  const atBeijing = (D, h) => D * DAY_MS - 28800000 + h * 3600000
396
- // 收集 ±SPAN 天内全部窗口边界切换点,剔除落在周末(无价格变化)的点。
559
+ // 某北京时间日 D 是否为「全天谷价日」:周末或法定节假日。
560
+ const dayOff = (D) => {
561
+ const wd = (D + 4) % 7
562
+ if (wd === 6 || wd === 0) return true
563
+ const set = PEAK_HOLIDAY_SET || (PEAK_HOLIDAY_SET = new Set(PEAK_HOLIDAY_LIST === null ? CN_HOLIDAYS : PEAK_HOLIDAY_LIST))
564
+ return set.has(holidayKeyOfDayIndex(D))
565
+ }
566
+ // 收集 ±SPAN 天内全部窗口边界切换点,剔除落在全天谷价日(无价格变化)的点。
397
567
  const points = []
398
568
  for (let off = -SPAN; off <= SPAN; off += 1) {
399
569
  const D = D0 + off
400
- const wd = (D + 4) % 7
401
- if (wd === 6 || wd === 0) continue // 周末日内无切换
570
+ if (dayOff(D)) continue // 周末 / 节假日日内无切换
402
571
  for (const w of PEAK_HOUR_WINDOWS) {
403
572
  points.push({ at: atBeijing(D, w.start), intoPeak: true })
404
573
  points.push({ at: atBeijing(D, w.end), intoPeak: false })
@@ -410,13 +579,24 @@ export function peakPhaseAt(ts, spanDays) {
410
579
  if (p.at <= ts && (prev === null || p.at > prev.at)) prev = p
411
580
  if (p.at > ts && (next === null || p.at < next.at)) next = p
412
581
  }
413
- if (isWeekendNow) {
414
- // 周末全谷价:当前谷,下一切换 = 下周一首个峰窗口起点;prev = 周六 00:00(北京)。
582
+ if (allDayOffNow) {
583
+ // 全天谷价:当前谷,下一切换 = 下一个非谷价日的首个峰窗口起点;
584
+ // prev = 本段连休起点(北京时间 00:00),便于「本段已持续多久」类展示。
415
585
  if (next === null) return null
416
- return { inPeak: false, weekend: true, prevAtMs: (D0 - weekday) * DAY_MS - 57600000, nextAtMs: next.at, nextIntoPeak: next.intoPeak }
586
+ let start = D0
587
+ for (let i = 0; i < SPAN && dayOff(start - 1); i += 1) start -= 1
588
+ return {
589
+ inPeak: false,
590
+ weekend: isWeekendNow,
591
+ holiday: isHolidayNow && !isWeekendNow,
592
+ allDayOff: true,
593
+ prevAtMs: start * DAY_MS - 28800000,
594
+ nextAtMs: next.at,
595
+ nextIntoPeak: next.intoPeak,
596
+ }
417
597
  }
418
598
  if (prev === null || next === null) return null
419
- return { inPeak: isPeak(ts), weekend: false, prevAtMs: prev.at, nextAtMs: next.at, nextIntoPeak: next.intoPeak }
599
+ return { inPeak: isPeak(ts), weekend: false, holiday: false, allDayOff: false, prevAtMs: prev.at, nextAtMs: next.at, nextIntoPeak: next.intoPeak }
420
600
  }
421
601
 
422
602
  /**
@@ -425,20 +605,71 @@ export function peakPhaseAt(ts, spanDays) {
425
605
  * @param {string} model - 模型名(如 deepseek-v4-flash-vision-exp)
426
606
  * @param {number} [ts] - 调用发生时刻(epoch ms);决定用哪一版单价表。
427
607
  * 缺省用当前时间——注意历史/测试场景应显式传入,否则跨价格时代会错。
608
+ * @param {{catalog?:Function, overrides?:Map, planOverrides?:object}} [opts]
609
+ * · catalog(np, model) → 目录命中对象 | null(vendor-catalog.catalogEntryFor,
610
+ * 由调用方注入以保持本模块可独立测试);
611
+ * · overrides:setPriceOverrides 注入的手动覆盖价(不传则用模块态);
612
+ * · planOverrides:订阅归类覆盖 {'provider/model'|'provider/*': 'plan'|'api'}。
428
613
  * @returns {{rates:object, tiered:boolean, estimated:boolean, subscription:boolean,
429
- * model:string, era:string|null}}
614
+ * model:string, era:string|null, source:string}}
430
615
  * model 为**计费模型规范名**:命中路由时是被路由到的模型(如 V4-Pro → V4.1 Flash),
431
616
  * 记账应以它入账;未命中精确表时为原模型名。
617
+ * source:override > plan > exact/synced > catalog > provider > generic。
432
618
  */
433
- export function priceFor(np, model, ts) {
619
+ export function priceFor(np, model, ts, opts) {
620
+ const o = opts || {}
621
+ // ---- 0. 订阅归类覆盖(用户在配置卡按 provider 或 provider/model 强制归类)----
622
+ const po = planOverrideFor(np, model, o.planOverrides)
623
+ if (po === 'plan') {
624
+ const sub = subscriptionPlanFor(np, model)
625
+ if (sub) return { rates: sub, tiered: false, estimated: true, subscription: true, model, era: null, source: 'plan' }
626
+ // 无既有套餐可套:按「该渠道走订阅」处理 —— 照常解析单价(目录/时代/兜底),
627
+ // 但标记为订阅等值口径;这正是「套餐覆盖了清单外的模型」的兜法。
628
+ const forced = resolveNonPlanPrice(np, model, ts, o)
629
+ forced.subscription = true
630
+ forced.source = 'plan'
631
+ return forced
632
+ }
633
+ if (po === 'api') {
634
+ const forced = resolveNonPlanPrice(np, model, ts, o)
635
+ forced.subscription = false
636
+ return forced
637
+ }
638
+ // ---- 1. 内置订阅套餐 ----
434
639
  const sub = subscriptionPlanFor(np, model)
435
- if (sub) return { rates: sub, tiered: false, estimated: true, subscription: true, model, era: null }
640
+ if (sub) return { rates: sub, tiered: false, estimated: true, subscription: true, model, era: null, source: 'plan' }
641
+ return resolveNonPlanPrice(np, model, ts, o)
642
+ }
643
+
644
+ /** 订阅归类覆盖查找:先 provider/model 精确,再 provider/* 通配 */
645
+ function planOverrideFor(np, model, map) {
646
+ if (!map || typeof map !== 'object') return ''
647
+ const nModel = normalizeModelName(model)
648
+ const nProv = normalizeModelName(np)
649
+ const exact = map[nProv + '/' + nModel]
650
+ if (exact === 'plan' || exact === 'api') return exact
651
+ const wild = map[nProv + '/*']
652
+ if (wild === 'plan' || wild === 'api') return wild
653
+ return ''
654
+ }
655
+
656
+ /** 非订阅路径的价格解析:覆盖价 > 时代精确表(内置+同步) > 目录 > provider 兜底 > 通用兜底 */
657
+ function resolveNonPlanPrice(np, model, ts, o) {
658
+ const ov = (o.overrides || PRICE_OVERRIDES)
659
+ const hit = ov.get(overrideKey(np, model))
660
+ if (hit) return { rates: hit.rates, tiered: hit.tiered, estimated: false, subscription: false, model, era: eraAt(ts).id, source: 'override' }
436
661
  const era = eraAt(ts)
437
- const hit = resolveModelInEra(era, model)
438
- if (hit) return { rates: era.models[hit], tiered: true, estimated: false, subscription: false, model: hit, era: era.id }
662
+ const exact = resolveModelInEra(era, model)
663
+ if (exact) return { rates: era.models[exact], tiered: true, estimated: false, subscription: false, model: exact, era: era.id, source: era.synced ? 'synced' : 'exact' }
664
+ if (typeof o.catalog === 'function') {
665
+ try {
666
+ const c = o.catalog(np, model)
667
+ if (c && c.rates) return { rates: c.rates, tiered: false, estimated: false, subscription: false, model, era: era.id, source: 'catalog', catalog: { provider: c.provider, sourceUrl: c.sourceUrl || '', checkedAt: c.checkedAt || '', via: c.via || '' } }
668
+ } catch (e) { /* 目录读取失败不阻断计费,落到 provider 兜底 */ }
669
+ }
439
670
  const p = PROVIDER_RATES[np]
440
- if (p) return { rates: p.rates, tiered: p.tiered, estimated: true, subscription: false, model, era: era.id }
441
- return { rates: GENERIC_RATES, tiered: false, estimated: true, subscription: false, model, era: era.id }
671
+ if (p) return { rates: p.rates, tiered: p.tiered, estimated: true, subscription: false, model, era: era.id, source: 'provider' }
672
+ return { rates: GENERIC_RATES, tiered: false, estimated: true, subscription: false, model, era: era.id, source: 'generic' }
442
673
  }
443
674
 
444
675
  /**
package/schema.js CHANGED
@@ -23,6 +23,10 @@ const TYPES = {};
23
23
  function anyNode(meta) {
24
24
  const node = (v) => v;
25
25
  node.meta = meta || {};
26
+ // 与其余类型同款的链式声明(v1.9.0 的 planOverrides/priceOverrides 用 any 承载)
27
+ node.role = (r) => { node.meta.role = r; return node }
28
+ node.default = (d) => { node.meta.default = d; return node }
29
+ node.description = (d) => { node.meta.description = d; return node }
26
30
  node.toJSON = () => ({ type: undefined, meta: node.meta });
27
31
  return node
28
32
  }
package/sync.js CHANGED
@@ -262,6 +262,8 @@ function classifyStatus(status, body) {
262
262
  /**
263
263
  * @param {object} deps
264
264
  * @param {() => object} deps.getConfig - 返回规范化后的插件配置(含 cloud* 字段)
265
+ * @param {() => Promise<string>|string} [deps.getToken] - 异步令牌提供者(v1.9.0:
266
+ * 令牌存 DSH 凭据库,配置文件零明文;未提供时回落 cfg.cloudToken 旧路径)
265
267
  * @param {() => {details:Array, rollups:object, resetEpoch:number, storageDir:string, maxSeq:number}} deps.getSnapshot
266
268
  * @param {(patch:object) => void} [deps.setConfigField] - 回写配置(记录同步结果/身份)
267
269
  * @param {typeof fetch} [deps.fetchFn]
@@ -270,6 +272,7 @@ function classifyStatus(status, body) {
270
272
  */
271
273
  export function createSyncEngine(deps) {
272
274
  const getConfig = deps.getConfig
275
+ const getToken = typeof deps.getToken === 'function' ? deps.getToken : null
273
276
  const getSnapshot = deps.getSnapshot
274
277
  const setConfigField = deps.setConfigField || (() => {})
275
278
  const fetchFn = deps.fetchFn || globalThis.fetch
@@ -277,6 +280,21 @@ export function createSyncEngine(deps) {
277
280
  const log = deps.log || (() => {})
278
281
  let identity = null
279
282
  let running = false
283
+ /** 最近一次成功解析的令牌(仅用于 status() 的 hasToken 回显,绝不进日志/配置) */
284
+ let lastKnownToken = ''
285
+
286
+ /** 令牌解析:凭据库提供者优先(异步),回落配置文件旧路径(迁移前的兜底) */
287
+ async function resolveToken(cfg) {
288
+ if (getToken) {
289
+ try {
290
+ const t = String((await getToken()) || '').trim()
291
+ if (t) { lastKnownToken = t; return t }
292
+ } catch (e) { /* 凭据服务暂不可用:回落 cfg */ }
293
+ }
294
+ const legacy = String(cfg.cloudToken || '').trim()
295
+ if (legacy) lastKnownToken = legacy
296
+ return legacy
297
+ }
280
298
 
281
299
  function identityOf() {
282
300
  if (!identity) {
@@ -444,7 +462,9 @@ export function createSyncEngine(deps) {
444
462
  result.error = '未启用云端同步或未填写服务地址'
445
463
  return result
446
464
  }
447
- if (!cfg.cloudToken) {
465
+ // 令牌:凭据库(getToken)优先,配置文件遗留明文兜底(迁移完成前)
466
+ const cloudToken = await resolveToken(cfg)
467
+ if (!cloudToken) {
448
468
  result.error = '未填写云端令牌'
449
469
  result.needAuth = true
450
470
  return result
@@ -492,7 +512,7 @@ export function createSyncEngine(deps) {
492
512
  batchUid: randomUUID(),
493
513
  records: pending.records,
494
514
  }
495
- const r = await postJson(base + '/api/v1/ingest/records', cfg.cloudToken, payload)
515
+ const r = await postJson(base + '/api/v1/ingest/records', cloudToken, payload)
496
516
  const cls = classifyStatus(r.status, r.body)
497
517
  if (!cls.ok) {
498
518
  if (cls.shrink && pending.records.length > 1) {
@@ -547,7 +567,7 @@ export function createSyncEngine(deps) {
547
567
  batchUid: randomUUID(),
548
568
  snapshots: chunk.map((x) => x.snapshot),
549
569
  }
550
- const r = await postJson(base + '/api/v1/ingest/rollups', cfg.cloudToken, payload)
570
+ const r = await postJson(base + '/api/v1/ingest/rollups', cloudToken, payload)
551
571
  const cls = classifyStatus(r.status, r.body)
552
572
  if (!cls.ok) throw Object.assign(new Error(cls.message || '快照上报失败'), { needAuth: cls.needAuth, retryAfterMs: cls.retryAfterMs, fatal: cls.fatal })
553
573
  result.rollups += Number(r.body.rollupsUpserted) || 0
@@ -628,7 +648,8 @@ export function createSyncEngine(deps) {
628
648
  return {
629
649
  enabled: cfg.cloudEnabled,
630
650
  url: cfg.cloudUrl,
631
- hasToken: !!cfg.cloudToken,
651
+ // v1.9.0:令牌在凭据库(getToken 已解析过则已知);配置文件明文仅是迁移前兜底
652
+ hasToken: !!cfg.cloudToken || !!lastKnownToken,
632
653
  deviceId: cfg.deviceId || id.machineId,
633
654
  deviceName: cfg.deviceName || id.machineName,
634
655
  watermark: st.watermark,