dsh-opencode-routing 2.2.1 → 2.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-opencode-routing",
-  "version": "2.2.1",
+  "version": "2.4.0",
   "type": "module",
   "description": "dsh plugin: OpenCode account pool with automatic A-to-B failover and quota routing, plus a per-account / per-model usage dashboard, in one Settings page.",
   "exports": {
@@ -16,6 +16,13 @@
     "client.js",
     "cordis.patch.yml",
     "README.md",
+    "README.zh-CN.md",
+    "README.zh-TW.md",
+    "README.ja.md",
+    "README.ko.md",
+    "README.ru.md",
+    "CONTRIBUTING.md",
+    "LICENSE",
     "test.mjs",
     "locale/*.json",
     "icon.svg"
@@ -42,6 +49,9 @@
     "multi-account",
     "quota",
     "router",
+    "routing",
+    "failover",
+    "i18n",
     "billing"
   ],
   "repository": {

package/test.mjs

@@ -14,7 +14,7 @@ import assert from 'node:assert/strict'
 
 import * as accounts from './index.js'
 import { apply as applyRouter, isExhausted, maskKey, nextProbeAt, retryAfter } from './router.js'
-import { apply as applyUsage, isChinaHoliday, peakMultiplier, peakSnapshot } from './usage.js'
+import { apply as applyUsage, isChinaHoliday, peakClock, peakMultiplier, peakSnapshot } from './usage.js'
 
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
 
@@ -70,6 +70,24 @@ assert.equal(isExhausted({ rolling: { status: 'ok', percent: 100 } }), true)
   assert.equal(holiday.models.every((row) => row.cheaper === 'go'), true)
   const plain = peakSnapshot(7.1, plainPeak, 'go')
   assert.ok(Math.abs(plain.models[0].ratio - 0.1) < 0.001, 'both peak: exactly the 10x discount')
+
+  // The page reports both calendars separately with a countdown to the flip.
+  const clockHoliday = peakClock(holidayPeak)
+  assert.equal(clockHoliday.holiday, true)
+  assert.equal(clockHoliday.official.peak, false, 'the official API is off-peak on a holiday')
+  assert.equal(clockHoliday.opencode.peak, true, 'OpenCode keeps billing the holiday as peak')
+  assert.equal(typeof clockHoliday.opencode.hours, 'number')
+  assert.ok(clockHoliday.opencode.hours > 0 && clockHoliday.opencode.hours <= 5, 'the window ends within 5 hours')
+
+  const clockPlain = peakClock(plainPeak)
+  assert.equal(clockPlain.official.peak, true)
+  assert.equal(clockPlain.opencode.peak, true)
+  assert.ok(clockPlain.opencode.hours >= 1.9 && clockPlain.opencode.hours <= 2.1, 'two hours left in the morning window')
+
+  const clockQuiet = peakClock(Date.parse('2026-02-24T12:00:00Z')) // Beijing 20:00
+  assert.equal(clockQuiet.official.peak, false)
+  assert.equal(clockQuiet.opencode.peak, false)
+  assert.ok(clockQuiet.opencode.hours > 0, 'a flip always lies ahead')
 }
 console.log('pure logic ok')
 
@@ -357,6 +375,23 @@ await sleep(300)
   assert.equal(freeRow.remaining, undefined, 'free models have no remaining quota')
   assert.equal(freeRow.inputs.includes('video'), true)
   assert.equal(data.peak.plan.leverage, 10)
+
+  // Every model breaks down into the three lines DeepSeek bills on, cheapest first
+  const peakFlash = data.peak.models.find((entry) => entry.model === 'deepseek-v4.1-flash')
+  assert.deepEqual(peakFlash.rows.map((line) => line.kind), ['cacheRead', 'input', 'output'])
+  assert.equal(peakFlash.rows[0].cheaper, 'go', 'the cached line is still cheaper on OpenCode')
+  assert.equal(Math.round(peakFlash.rows[0].ratio * 100) / 100, 0.1)
+}
+
+// A plan change is a config edit, not a code change: the discount is derived
+{
+  const offPeak = Date.UTC(2026, 10, 3, 16, 0)
+  const cheaper = peakSnapshot(7.1, offPeak, 'go', { priceUsd: 10, allowanceUsd: 50 })
+  assert.equal(cheaper.plan.leverage, 5, 'a smaller allowance halves the discount')
+  assert.equal(cheaper.plan.overridden, true)
+  const dearer = peakSnapshot(7.1, offPeak, 'go', { priceUsd: 50, allowanceUsd: 100 })
+  assert.equal(dearer.plan.leverage, 2)
+  assert.equal(dearer.models[0].rows[0].cheaper, 'go', 'still cheaper, just less so')
 }
 console.log('usage view ok')
 

package/usage.js

@@ -230,6 +230,11 @@ function normalize(config = {}) {
     // our own schedule, not DeepSeek's holiday calendar"), so this stays off by
     // default — the dashboard is about the Go bill.
     holidayAware: config.holidayAware === true,
+    // The subscription price and its monthly allowance can be overridden here,
+    // so a plan change from OpenCode needs a config edit, not a patch: the
+    // discount shown on the page is derived from these two numbers.
+    planPriceUsd: Number.isFinite(config.planPriceUsd) && config.planPriceUsd > 0 ? config.planPriceUsd : undefined,
+    planAllowanceUsd: Number.isFinite(config.planAllowanceUsd) && config.planAllowanceUsd > 0 ? config.planAllowanceUsd : undefined,
     limits: LIMITS[plan],
   }
 }
@@ -287,45 +292,106 @@ export function peakMultiplier(model, at, holidayAware = false) {
   return PEAK.utcWeekdayHours.some(([from, to]) => hour >= from && hour < to) ? PEAK.factor : 1
 }
 
+/** Is `side` billing at peak right now?
+ *
+ *  The two sides keep different calendars: DeepSeek's own API treats Chinese
+ *  statutory holidays as off-peak, while OpenCode bills by its weekday schedule
+ *  only (anomalyco/opencode#53071). Both use the same wall-clock windows, so the
+ *  only difference is the holiday rule. */
+export function peakAt(side, at = Date.now()) {
+  const date = new Date(at)
+  const day = date.getUTCDay()
+  if (day === 0 || day === 6) return false
+  const hour = date.getUTCHours()
+  if (!PEAK.utcWeekdayHours.some(([from, to]) => hour >= from && hour < to)) return false
+  return side === 'official' ? !isChinaHoliday(at) : true
+}
+
+/** The peak windows start and end on these hours, so a flip can only happen at
+ *  one of them — no need to scan every minute. */
+const PEAK_BOUNDARIES = PEAK.utcWeekdayHours.flatMap(([from, to]) => [from, to])
+
+/** Peak state for both sides, plus how long until each one flips, in hours with
+ *  one decimal. */
+export function peakClock(at = Date.now()) {
+  const side = (name) => {
+    const peak = peakAt(name, at)
+    const base = new Date(at)
+    let next = null
+    for (let day = 0; day < 14 && next === null; day += 1) {
+      for (const hour of PEAK_BOUNDARIES) {
+        const point = Date.UTC(base.getUTCFullYear(), base.getUTCMonth(), base.getUTCDate() + day, hour, 0, 0, 0)
+        if (point <= at) continue
+        if (peakAt(name, point) === peak) continue
+        next = point
+        break
+      }
+    }
+    const hours = next === null ? null : Math.round(((next - at) / HOUR) * 10) / 10
+    return { peak, next, hours }
+  }
+  return { at, holiday: isChinaHoliday(at), official: side('official'), opencode: side('opencode') }
+}
+
 /** What each plan costs per month, in USD. The plan's allowance is metered at
  *  DeepSeek's list price, so the subscription buys its allowance at a fixed
  *  discount — Go pays $10 for $100 of list-priced usage, i.e. 10x. */
 const PLAN_PRICES = { go: 10, 'go-plus': 40, 'go-teams': 20 }
 
+/** The three lines DeepSeek bills on, in the order the page shows them: a cached
+ *  prompt token is by far the cheapest, so it leads. */
+export const BILLING_KINDS = ['cacheRead', 'input', 'output']
+
 /** Which route is cheaper at this instant, expressed in the money you actually
- *  hand over: Go charges the list price against a 10x-discounted allowance, while
- *  DeepSeek's API bills the list price directly. */
-export function peakSnapshot(cnyPerUsd, at = Date.now(), plan = 'go') {
+ *  hand over: OpenCode charges the list price against a discounted allowance,
+ *  while DeepSeek's API bills the list price directly.
+ *
+ *  `overrides` lets the settings page (or a future price change) replace the
+ *  plan price and its allowance without touching this file: the discount is
+ *  derived, so editing either number re-derives the verdict on its own. */
+export function peakSnapshot(cnyPerUsd, at = Date.now(), plan = 'go', overrides = {}) {
   const fx = Number.isFinite(cnyPerUsd) && cnyPerUsd > 0 ? cnyPerUsd : OFFICIAL.defaultCnyPerUsd
-  const priceUsd = PLAN_PRICES[plan] ?? PLAN_PRICES.go
-  const allowanceUsd = LIMITS[plan]?.['deepseek-v4.1-flash'] ?? LIMITS.go['deepseek-v4.1-flash']
+  const priceUsd = Number.isFinite(overrides.priceUsd) && overrides.priceUsd > 0
+    ? overrides.priceUsd
+    : PLAN_PRICES[plan] ?? PLAN_PRICES.go
+  const listed = LIMITS[plan]?.['deepseek-v4.1-flash'] ?? LIMITS.go['deepseek-v4.1-flash']
+  const allowanceUsd = Number.isFinite(overrides.allowanceUsd) && overrides.allowanceUsd > 0
+    ? overrides.allowanceUsd
+    : listed
   const leverage = allowanceUsd / priceUsd
   const routes = []
   for (const [model, official] of Object.entries(OFFICIAL.prices)) {
     const goFactor = peakMultiplier(model, at, false)
     const officialFactor = peakMultiplier(model, at, true)
-    // One million output tokens is the yardstick: output dominates a coding bill.
-    const list = official.output
-    const burn = list * goFactor // what the request subtracts from the allowance
-    const goPay = burn / leverage // what it actually costs you, given the discount
-    const officialPay = list * officialFactor
+    const rows = BILLING_KINDS.map((kind) => {
+      // One million tokens of this kind is the yardstick; output dominates a
+      // coding bill, so the headline verdict still reads off the output line.
+      const list = official[kind]
+      const burn = list * goFactor // what the request subtracts from the allowance
+      const goPay = burn / leverage // what it actually costs you, given the discount
+      const officialPay = list * officialFactor
+      return { kind, list, go: { factor: goFactor, burn, pay: goPay }, official: { factor: officialFactor, pay: officialPay }, cheaper: goPay <= officialPay ? 'go' : 'official', ratio: goPay / officialPay }
+    })
+    const headline = rows[rows.length - 1]
     routes.push({
       model,
-      list,
-      go: { factor: goFactor, burn, pay: goPay },
-      official: { factor: officialFactor, pay: officialPay },
-      cheaper: goPay <= officialPay ? 'go' : 'official',
-      ratio: goPay / officialPay,
+      rows,
+      list: headline.list,
+      go: headline.go,
+      official: headline.official,
+      cheaper: headline.cheaper,
+      ratio: headline.ratio,
     })
   }
   return {
     at,
     cnyPerUsd: fx,
     holiday: isChinaHoliday(at),
-    plan: { id: plan, priceUsd, priceCny: priceUsd * fx, allowanceUsd, allowanceCny: allowanceUsd * fx, leverage },
+    plan: { id: plan, priceUsd, priceCny: priceUsd * fx, allowanceUsd, allowanceCny: allowanceUsd * fx, leverage, overridden: Boolean(overrides.priceUsd || overrides.allowanceUsd) },
     go: { peak: peakMultiplier('deepseek-v4.1-flash', at, false) === PEAK.factor },
     official: { peak: peakMultiplier('deepseek-v4.1-flash', at, true) === PEAK.factor },
     factor: PEAK.factor,
+    kinds: BILLING_KINDS,
     models: routes,
   }
 }
@@ -659,7 +725,11 @@ export function apply(ctx, config = {}) {
       startedAt,
       windowStarts: starts,
       holidayAware: cfg.holidayAware,
-      peak: peakSnapshot(cfg.cnyPerUsd, Date.now(), detectedPlan ?? cfg.plan),
+      clock: peakClock(),
+      peak: peakSnapshot(cfg.cnyPerUsd, Date.now(), detectedPlan ?? cfg.plan, {
+        priceUsd: cfg.planPriceUsd,
+        allowanceUsd: cfg.planAllowanceUsd,
+      }),
       usage: usageSnapshot,
       usageError,
       accounts,