@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/CHANGELOG.md +210 -0
- package/README.en.md +112 -2
- package/README.md +112 -4
- package/client.js +781 -159
- package/config.js +139 -1
- package/credstore.js +248 -0
- package/docs/THIRD-PARTY-NOTICES.md +60 -0
- package/docs/provider-pricing.json +777 -0
- package/import.js +363 -0
- package/index.js +608 -89
- package/package.json +11 -3
- package/price-sync.js +216 -0
- package/pricing.js +291 -60
- package/schema.js +4 -0
- package/sync.js +25 -4
- package/vendor-catalog.js +198 -0
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
|
-
//
|
|
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
|
-
//
|
|
15
|
-
// 12:00
|
|
16
|
-
//
|
|
17
|
-
//
|
|
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
|
|
81
|
-
//
|
|
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
|
-
/**
|
|
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
|
-
|
|
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
|
|
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
|
-
* -
|
|
379
|
-
* -
|
|
380
|
-
*
|
|
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,
|
|
384
|
-
* nextIntoPeak:boolean}|null}
|
|
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
|
-
|
|
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
|
-
//
|
|
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
|
-
|
|
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 (
|
|
414
|
-
//
|
|
582
|
+
if (allDayOffNow) {
|
|
583
|
+
// 全天谷价:当前谷,下一切换 = 下一个非谷价日的首个峰窗口起点;
|
|
584
|
+
// prev = 本段连休起点(北京时间 00:00),便于「本段已持续多久」类展示。
|
|
415
585
|
if (next === null) return null
|
|
416
|
-
|
|
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
|
|
438
|
-
if (
|
|
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
|
-
|
|
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',
|
|
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',
|
|
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
|
-
|
|
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,
|