@cassius0924/dsh-usage-dashboard 0.5.0 → 0.6.0

package/lib/index.js

@@ -60,32 +60,71 @@ function isTrustedApiRequest(req) {
 
 // src/pricing.ts
 var PEAK_PRICING_FROM_MS = Date.UTC(2026, 7, 16, 16, 0, 0);
+var V41_FLASH_PRICING_FROM_MS = Date.UTC(2026, 8, 10, 4, 0, 0);
+var PRO_ROUTED_TO_FLASH_FROM_MS = Date.UTC(2026, 8, 14, 4, 0, 0);
 var PEAK_WINDOWS = [[9, 12], [14, 18]];
 var BEIJING_OFFSET_MS = 8 * 36e5;
-var LEGACY_RATES = {
+var FLAT_RATES = {
   pro: { cacheHit: 0.025, input: 3, output: 6 },
-  flash: { cacheHit: 0.02, input: 1, output: 2 }
+  flash: { cacheHit: 0.02, input: 1, output: 2 },
+  // The vision model billed at flash rates from day one, so its pre-switch
+  // history is costed at the same flat prices as flash.
+  vision: { cacheHit: 0.02, input: 1, output: 2 }
 };
-var PEAK_RATES = {
+var PEAK_RATES_08_17 = {
   pro: { cacheHit: 0.3, input: 9, output: 27 },
-  flash: { cacheHit: 0.1, input: 3, output: 9 }
+  flash: { cacheHit: 0.1, input: 3, output: 9 },
+  // Official policy: the vision model is priced identically to flash; images
+  // cost tokens, not their own multiplier.
+  vision: { cacheHit: 0.1, input: 3, output: 9 }
 };
+var PEAK_RATES_09_10 = {
+  pro: { cacheHit: 0.3, input: 9, output: 27 },
+  flash: { cacheHit: 0.04, input: 2, output: 8 },
+  vision: { cacheHit: 0.04, input: 2, output: 8 }
+};
+var PRICE_ERAS = [
+  { fromMs: PEAK_PRICING_FROM_MS, peak: PEAK_RATES_08_17, weekdaysOnly: false },
+  { fromMs: V41_FLASH_PRICING_FROM_MS, peak: PEAK_RATES_09_10, weekdaysOnly: true }
+];
+function eraAt(timeMs) {
+  let era = PRICE_ERAS[0];
+  for (const candidate of PRICE_ERAS) if (timeMs >= candidate.fromMs) era = candidate;
+  return era;
+}
 var halved = (rates) => ({
   cacheHit: rates.cacheHit / 2,
   input: rates.input / 2,
   output: rates.output / 2
 });
 function tierOf(model) {
-  return model.toLowerCase().includes("flash") ? "flash" : "pro";
+  const name2 = model.toLowerCase();
+  if (name2.includes("vision")) return "vision";
+  if (name2.includes("flash")) return "flash";
+  return "pro";
+}
+function billedTierOf(timeMs, model) {
+  const tier = tierOf(model);
+  return tier === "pro" && timeMs >= PRO_ROUTED_TO_FLASH_FROM_MS ? "flash" : tier;
+}
+function isBeijingWeekday(timeMs) {
+  const day = new Date(timeMs + BEIJING_OFFSET_MS).getUTCDay();
+  return day >= 1 && day <= 5;
+}
+function estimateImageTokens(width, height) {
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) return 0;
+  const area = width * height;
+  const scaledArea = Math.min(800 * 800, Math.max(384 * 384, area));
+  return 384 * (scaledArea / (800 * 800));
 }
 function isPeak(timeMs) {
+  if (eraAt(timeMs).weekdaysOnly && !isBeijingWeekday(timeMs)) return false;
   const hour = Math.floor(((timeMs + BEIJING_OFFSET_MS) % 864e5 + 864e5) % 864e5 / 36e5);
   return PEAK_WINDOWS.some(([from, to]) => hour >= from && hour < to);
 }
 function ratesAt(timeMs, model) {
-  const tier = tierOf(model);
-  if (timeMs < PEAK_PRICING_FROM_MS) return LEGACY_RATES[tier];
-  const peak = PEAK_RATES[tier];
+  if (timeMs < PEAK_PRICING_FROM_MS) return FLAT_RATES[tierOf(model)];
+  const peak = eraAt(timeMs).peak[billedTierOf(timeMs, model)];
   return isPeak(timeMs) ? peak : halved(peak);
 }
 function cacheSavingOf(timeMs, model, cache) {
@@ -97,23 +136,19 @@ function costOf(timeMs, model, input, cache, output) {
   return applyRates(ratesAt(timeMs, model), input, cache, output);
 }
 function costUnderPeakEra(timeMs, model, input, cache, output, forceOffPeak = false) {
-  const peak = PEAK_RATES[tierOf(model)];
+  const peak = PRICE_ERAS[PRICE_ERAS.length - 1].peak[billedTierOf(timeMs, model)];
   const rates = !forceOffPeak && isPeak(timeMs) ? peak : halved(peak);
   return applyRates(rates, input, cache, output);
 }
 function pricingInfo(nowMs) {
-  const split = nowMs >= PEAK_PRICING_FROM_MS;
+  const era = eraAt(nowMs);
+  const row = (model, tier) => ({ model, peak: era.peak[tier], offPeak: halved(era.peak[tier]) });
   return {
     currency: "CNY",
     switchDate: "2026-08-17",
-    splitActive: split,
-    inPeakNow: split && isPeak(nowMs),
+    inPeakNow: isPeak(nowMs),
     peakWindows: ["09:00\u201312:00", "14:00\u201318:00"],
-    tiers: ["pro", "flash"].map((tier) => ({
-      model: tier === "pro" ? "deepseek-v4-pro" : "deepseek-v4-flash",
-      peak: split ? PEAK_RATES[tier] : LEGACY_RATES[tier],
-      offPeak: split ? halved(PEAK_RATES[tier]) : null
-    }))
+    tiers: [row("deepseek-flash", "flash"), row("deepseek-v4-pro", "pro")]
   };
 }
 
@@ -175,6 +210,18 @@ function bump(map, key, input, output, cache, cost) {
   map.set(key, bucket);
 }
 var emptyOverall = () => ({ ...emptyBucket(), reasoning: 0, cacheSavings: 0 });
+var emptyVision = () => ({ images: 0, imageTokens: 0, cost: 0, bytes: 0 });
+function bumpVisionInto(acc, images, imageTokens, cost, bytes) {
+  acc.images += images;
+  acc.imageTokens += imageTokens;
+  acc.cost += cost;
+  acc.bytes += bytes;
+}
+function bumpVisionMap(map, key, images, imageTokens, cost, bytes) {
+  const acc = map.get(key) ?? emptyVision();
+  bumpVisionInto(acc, images, imageTokens, cost, bytes);
+  map.set(key, acc);
+}
 var SESSION_TOP_N = 6;
 function titleOf(events, id) {
   let title = "";
@@ -217,6 +264,7 @@ function addUsageEvent(events, onEvent) {
   if (events === void 0) return result;
   let provider = "";
   let model = "";
+  const pendingImages = [];
   for (const ev of events) {
     if (ev?.type === "request/header") {
       const cfg = ev.data?.header?.config;
@@ -226,6 +274,7 @@ function addUsageEvent(events, onEvent) {
       }
       continue;
     }
+    pendingImages.push(...imagesInEvent(ev));
     if (ev?.type !== "assistant/message") continue;
     const usage = ev.data?.usage;
     if (usage === void 0) continue;
@@ -239,11 +288,56 @@ function addUsageEvent(events, onEvent) {
     const messageId = typeof rawMessageId === "string" && rawMessageId !== "" ? rawMessageId : void 0;
     const rawTurn = ev.data?.turn;
     const turn = typeof rawTurn === "number" && Number.isFinite(rawTurn) ? rawTurn : void 0;
-    onEvent(ev.time, input, output, cache, reasoning, provider, model, messageId, turn);
+    onEvent(ev.time, input, output, cache, reasoning, provider, model, messageId, turn, pendingImages);
+    pendingImages.length = 0;
     result.usageRecords += 1;
   }
   return result;
 }
+function imageBlocks(blocks) {
+  const found = [];
+  const walkAll = (items) => {
+    for (const item of items ?? []) {
+      if (item?.type === "image" && item.attachment !== void 0 && item.attachment !== null) {
+        found.push(item.attachment);
+      }
+      if (Array.isArray(item?.content)) walkAll(item.content);
+    }
+  };
+  walkAll(blocks);
+  return found;
+}
+function imagesInEvent(ev) {
+  if (ev === void 0) return [];
+  return [
+    ...imageBlocks(ev.data?.content),
+    ...imageBlocks(ev.data?.message?.content)
+  ];
+}
+async function readSessionEvents(persistence, id) {
+  if (typeof persistence.open === "function") {
+    const handle = await persistence.open(id, "read");
+    try {
+      const events2 = [];
+      for (; ; ) {
+        const slice = await handle.read(events2.length);
+        const batch = slice.events ?? [];
+        if (batch.length === 0) return events2;
+        for (const event of batch) events2.push(event);
+      }
+    } finally {
+      try {
+        await handle.close();
+      } catch {
+      }
+    }
+  }
+  if (persistence.readFrom === void 0) {
+    throw new Error("\u5BBF\u4E3B sessionPersistence \u7F3A\u5C11 open() \u4E0E readFrom()\uFF0C\u65E0\u6CD5\u8BFB\u53D6\u4F1A\u8BDD\u65E5\u5FD7");
+  }
+  const { events } = await persistence.readFrom(id, 0);
+  return events;
+}
 async function fetchUsage(persistence, nowMs = Date.now()) {
   if (persistence === void 0) return { ok: false, error: "\u4F1A\u8BDD\u6301\u4E45\u5316\u670D\u52A1\u4E0D\u53EF\u7528" };
   let headers;
@@ -259,6 +353,9 @@ async function fetchUsage(persistence, nowMs = Date.now()) {
   const modelDays = /* @__PURE__ */ new Map();
   const modelHours = /* @__PURE__ */ new Map();
   const sessions = [];
+  const vision = emptyVision();
+  const visionDays = /* @__PURE__ */ new Map();
+  const visionSessions = /* @__PURE__ */ new Map();
   const coverage = {
     scope: "local-dsh-session-logs",
     listedSessions: 0,
@@ -287,7 +384,10 @@ async function fetchUsage(persistence, nowMs = Date.now()) {
     modelTotals: /* @__PURE__ */ new Map(),
     modelDays: /* @__PURE__ */ new Map(),
     modelHours: /* @__PURE__ */ new Map(),
-    sessions: []
+    sessions: [],
+    vision: emptyVision(),
+    visionDays: /* @__PURE__ */ new Map(),
+    visionSessions: /* @__PURE__ */ new Map()
   }));
   const bumpOverall = (bucket, input, output, cache, reasoning, cost, cacheSavings) => {
     bucket.input += input;
@@ -320,15 +420,17 @@ async function fetchUsage(persistence, nowMs = Date.now()) {
     session.calls += 1;
     if (time > session.lastActive) session.lastActive = time;
   };
-  const sessionIds = headers.map((header) => header.id ?? header.sessionId).filter((sid) => sid !== void 0 && sid !== "");
+  const sessionIds = headers.map((header) => header.id ?? header.sessionId ?? header.header?.id ?? header.header?.sessionId).filter((sid) => sid !== void 0 && sid !== "");
   coverage.listedSessions = sessionIds.length;
   for (const sid of sessionIds) {
     try {
-      const { events } = await persistence.readFrom(sid, 0);
+      const events = await readSessionEvents(persistence, sid);
       coverage.scannedSessions += 1;
       const session = { id: sid, title: "", total: 0, cost: 0, calls: 0, lastActive: 0 };
       const windowSessions = windowAggregates.map(() => ({ id: sid, title: "", total: 0, cost: 0, calls: 0, lastActive: 0 }));
-      const scanned = addUsageEvent(events, (time, input, output, cache, reasoning, provider, model) => {
+      const sessionVision = { ...emptyVision(), title: "" };
+      const windowVisionSessions = windowAggregates.map(() => ({ ...emptyVision(), title: "" }));
+      const scanned = addUsageEvent(events, (time, input, output, cache, reasoning, provider, model, _messageId, _turn, images) => {
         if (coverage.earliestAt === null || time < coverage.earliestAt) coverage.earliestAt = time;
         if (coverage.latestAt === null || time > coverage.latestAt) coverage.latestAt = time;
         const d = new Date(time);
@@ -343,6 +445,29 @@ async function fetchUsage(persistence, nowMs = Date.now()) {
         bumpModel(modelTotals, modelDays, modelHours, modelKey, dayKey, hourKey, input, output, cache, cost);
         bumpOverall(overall, input, output, cache, reasoning, cost, cacheSavings);
         bumpSession(session, time, eventTotal, cost);
+        if (images.length > 0) {
+          let imageTokensSum = 0;
+          let imageCostSum = 0;
+          let imageBytesSum = 0;
+          for (const image of images) {
+            const width = typeof image.width === "number" ? image.width : 0;
+            const height = typeof image.height === "number" ? image.height : 0;
+            const tokens = estimateImageTokens(width, height);
+            imageTokensSum += tokens;
+            imageCostSum += costOf(time, model, tokens, 0, 0);
+            imageBytesSum += typeof image.bytes === "number" ? image.bytes : 0;
+          }
+          bumpVisionInto(vision, images.length, imageTokensSum, imageCostSum, imageBytesSum);
+          bumpVisionMap(visionDays, dayKey, images.length, imageTokensSum, imageCostSum, imageBytesSum);
+          bumpVisionInto(sessionVision, images.length, imageTokensSum, imageCostSum, imageBytesSum);
+          for (let i = 0; i < windowAggregates.length; i++) {
+            const aggregate = windowAggregates[i];
+            if (dayKey < aggregate.startKey || dayKey > aggregate.endKey) continue;
+            bumpVisionInto(aggregate.vision, images.length, imageTokensSum, imageCostSum, imageBytesSum);
+            bumpVisionMap(aggregate.visionDays, dayKey, images.length, imageTokensSum, imageCostSum, imageBytesSum);
+            bumpVisionInto(windowVisionSessions[i], images.length, imageTokensSum, imageCostSum, imageBytesSum);
+          }
+        }
         for (let i = 0; i < windowAggregates.length; i++) {
           const aggregate = windowAggregates[i];
           if (dayKey < aggregate.startKey || dayKey > aggregate.endKey) continue;
@@ -372,6 +497,16 @@ async function fetchUsage(persistence, nowMs = Date.now()) {
           windowAggregates[i].sessions.push(windowSession);
         }
       }
+      if (sessionVision.images > 0) {
+        sessionVision.title = titleOf(events, sid);
+        visionSessions.set(sid, sessionVision);
+        for (let i = 0; i < windowAggregates.length; i++) {
+          const windowVision = windowVisionSessions[i];
+          if (windowVision.images === 0) continue;
+          windowVision.title = sessionVision.title;
+          windowAggregates[i].visionSessions.set(sid, windowVision);
+        }
+      }
     } catch {
       coverage.failedSessions += 1;
     }
@@ -427,6 +562,22 @@ async function fetchUsage(persistence, nowMs = Date.now()) {
     const b = dayMap.get(key) ?? emptyBucket();
     heatmap.push({ date: key, total: b.total, cost: b.cost, calls: b.calls });
   }
+  const makeVisionDaily = (map, count) => {
+    const result = [];
+    for (let i = count - 1; i >= 0; i--) {
+      const key = dayKeyOf(dateBefore(i));
+      const b = map.get(key) ?? emptyVision();
+      result.push({ date: key, images: b.images, imageTokens: b.imageTokens, cost: b.cost });
+    }
+    return result;
+  };
+  const makeVisionSessions = (map) => [...map.entries()].map(([id, acc]) => ({
+    id,
+    title: acc.title !== "" ? acc.title : `\u4F1A\u8BDD ${id.slice(0, 8)}`,
+    images: acc.images,
+    imageTokens: acc.imageTokens,
+    cost: acc.cost
+  })).sort((a, b) => b.images - a.images).slice(0, SESSION_TOP_N);
   const models = makeModels(modelTotals, modelDays, modelHours, 30);
   const windows = windowAggregates.map((aggregate) => ({
     days: aggregate.days,
@@ -435,7 +586,10 @@ async function fetchUsage(persistence, nowMs = Date.now()) {
     totals: { ...aggregate.overall },
     models: makeModels(aggregate.modelTotals, aggregate.modelDays, aggregate.modelHours, aggregate.days),
     sessions: [...aggregate.sessions].sort((a, b) => b.cost - a.cost).slice(0, SESSION_TOP_N),
-    sessionCount: aggregate.sessions.length
+    sessionCount: aggregate.sessions.length,
+    vision: { ...aggregate.vision },
+    visionDaily: makeVisionDaily(aggregate.visionDays, aggregate.days),
+    visionSessions: makeVisionSessions(aggregate.visionSessions)
   }));
   return {
     ok: true,
@@ -451,6 +605,9 @@ async function fetchUsage(persistence, nowMs = Date.now()) {
       sessionCount: sessions.length,
       coverage,
       windows,
+      vision: { ...vision },
+      visionDaily: makeVisionDaily(visionDays, 30),
+      visionSessions: makeVisionSessions(visionSessions),
       totals: {
         input: overall.input,
         output: overall.output,
@@ -470,8 +627,7 @@ async function fetchSessionUsage(persistence, sessionId) {
   if (!isValidSessionId(sessionId)) return { ok: false, error: "\u4F1A\u8BDD id \u683C\u5F0F\u4E0D\u5408\u6CD5" };
   let events;
   try {
-    const result = await persistence.readFrom(sessionId, 0);
-    events = result.events;
+    events = await readSessionEvents(persistence, sessionId);
   } catch (err) {
     return { ok: false, error: `\u8BFB\u53D6\u4F1A\u8BDD\u65E5\u5FD7\u5931\u8D25\uFF1A${errorMessage(err)}` };
   }