@rayadesu/dsh-llm-billing 0.3.8 → 0.3.10

package/lib/types/billing.js

@@ -21,25 +21,77 @@ export const DEFAULT_PEAK_HOURS = [
     { start: 9, end: 12 },
     { start: 14, end: 18 },
 ];
-/** Official peak/off-peak rates (CNY per 1M tokens), effective 2026-08-17. */
+/**
+ * Inclusive epoch ms of the published V4 Flash series re-pricing:
+ * 2026-09-10 12:00 Beijing time (UTC+8, no DST) = 04:00 UTC. Samples before
+ * this instant keep the base rates; samples at or after it bill at the second
+ * revision.
+ */
+export const FLASH_SERIES_RATE_CHANGE_AT = Date.UTC(2026, 8, 10, 4, 0, 0);
+/**
+ * Inclusive epoch ms of the announced V4 Pro route switch: 2026-09-14 12:00
+ * Beijing time (UTC+8, no DST) = 04:00 UTC. From that instant the V4 Pro route
+ * is served by V4.1 Flash and billed at the V4.1 Flash rates.
+ */
+export const V4_PRO_ROUTE_SWITCH_AT = Date.UTC(2026, 8, 14, 4, 0, 0);
+/** The V4 Flash series' base rates (effective 2026-08-17), CNY per 1M tokens. */
+const FLASH_BASE_RATES = {
+    peak: { cacheHitInput: 0.10, cacheMissInput: 3.0, output: 9.0 },
+    offPeak: { cacheHitInput: 0.05, cacheMissInput: 1.5, output: 4.5 },
+};
+/**
+ * The V4 Flash series' second revision (effective
+ * {@link FLASH_SERIES_RATE_CHANGE_AT}): off-peak 0.02 / 1.0 / 4.0, peak at
+ * twice those prices.
+ */
+const FLASH_REPRICED_RATES = {
+    effectiveFrom: FLASH_SERIES_RATE_CHANGE_AT,
+    peak: { cacheHitInput: 0.04, cacheMissInput: 2.0, output: 8.0 },
+    offPeak: { cacheHitInput: 0.02, cacheMissInput: 1.0, output: 4.0 },
+};
+/**
+ * The V4.1 Flash rates as they reach the retired V4 Pro route from
+ * {@link V4_PRO_ROUTE_SWITCH_AT}: the same price pair as the flash series'
+ * second revision, carried at its own effective instant.
+ */
+const V4_PRO_SWITCHED_RATES = {
+    effectiveFrom: V4_PRO_ROUTE_SWITCH_AT,
+    peak: FLASH_REPRICED_RATES.peak,
+    offPeak: FLASH_REPRICED_RATES.offPeak,
+};
+/**
+ * Official peak/off-peak rates (CNY per 1M tokens) per model, as dated
+ * revisions. Base rows are the schedule effective 2026-08-17; the V4 Flash
+ * series (V4.1 Flash, V4 Flash, V4 Flash Vision Exp) carries the second
+ * revision effective 2026-09-10 12:00 Beijing, and the V4 Pro row the V4.1
+ * Flash rates from its announced route switch (2026-09-14 12:00 Beijing) —
+ * the MiMo-V2.5 series is untouched by either adjustment. Rows sharing a model
+ * are that model's rate history.
+ */
 export const DEFAULT_MODEL_PRICING = [
-    {
-        model: 'deepseek-v4-flash',
-        peak: { cacheHitInput: 0.10, cacheMissInput: 3.0, output: 9.0 },
-        offPeak: { cacheHitInput: 0.05, cacheMissInput: 1.5, output: 4.5 },
-    },
+    // deepseek-flash is the V4.1 Flash route, DSH's default catalog entry; image
+    // inputs are converted to tokens at the same per-token price.
+    { model: 'deepseek-flash', ...FLASH_BASE_RATES },
+    { model: 'deepseek-flash', ...FLASH_REPRICED_RATES },
+    { model: 'deepseek-v4-flash', ...FLASH_BASE_RATES },
+    { model: 'deepseek-v4-flash', ...FLASH_REPRICED_RATES },
+    // deepseek-v4.1-flash-expires-on-0910 was the V4.1 Flash preview route,
+    // retired when the model was released on 2026-09-10; its rows stay so the
+    // logs that used it keep pricing.
+    { model: 'deepseek-v4.1-flash-expires-on-0910', ...FLASH_BASE_RATES },
+    { model: 'deepseek-v4.1-flash-expires-on-0910', ...FLASH_REPRICED_RATES },
     {
         model: 'deepseek-v4-pro',
         peak: { cacheHitInput: 0.30, cacheMissInput: 9.0, output: 27.0 },
         offPeak: { cacheHitInput: 0.15, cacheMissInput: 4.5, output: 13.5 },
     },
+    // From the announced route switch V4 Pro is served by V4.1 Flash and billed
+    // at the V4.1 Flash rates.
+    { model: 'deepseek-v4-pro', ...V4_PRO_SWITCHED_RATES },
     // deepseek-v4-flash-vision-exp bills at the same rates as deepseek-v4-flash;
     // images are converted to tokens at the same per-token price.
-    {
-        model: 'deepseek-v4-flash-vision-exp',
-        peak: { cacheHitInput: 0.10, cacheMissInput: 3.0, output: 9.0 },
-        offPeak: { cacheHitInput: 0.05, cacheMissInput: 1.5, output: 4.5 },
-    },
+    { model: 'deepseek-v4-flash-vision-exp', ...FLASH_BASE_RATES },
+    { model: 'deepseek-v4-flash-vision-exp', ...FLASH_REPRICED_RATES },
     // MiMo-V2.5 series (Xiaomi): flat rate, no peak/off-peak distinction.
     {
         model: 'mimo-v2.5-pro',
@@ -58,8 +110,14 @@ export const DEFAULT_MODEL_PRICING = [
  * `z.array` as `[]` rather than `undefined`, so emptiness — not just absence —
  * selects the defaults. Explicit non-empty rows override the same model; a
  * supplied non-empty `models` list is authoritative.
+ *
+ * Rows sharing a model are that model's rate revisions, kept in ascending
+ * `effectiveFrom` order (an undated base revision first). Two rows declaring
+ * the same effective instant are one revision and the later row wins — the
+ * historical override rule — so re-declaring a model can neither duplicate a
+ * revision nor install a second undated base.
  * @param config - optional raw billing configuration.
- * @returns the resolved table and peak-hour windows.
+ * @returns the resolved table (per model: its revisions plus the newest rates) and peak-hour windows.
  */
 export function resolveBilling(config) {
     const peakHours = config?.peakHours !== undefined && config.peakHours.length > 0
@@ -68,28 +126,107 @@ export function resolveBilling(config) {
     const rows = config?.models !== undefined && config.models.length > 0
         ? config.models
         : DEFAULT_MODEL_PRICING;
+    const schedules = new Map();
+    for (const row of rows) {
+        // Spelled out per branch: `exactOptionalPropertyTypes` forbids handing an
+        // explicit `undefined` to an optional field.
+        const revision = row.effectiveFrom === undefined
+            ? { peak: row.peak, offPeak: row.offPeak }
+            : { effectiveFrom: row.effectiveFrom, peak: row.peak, offPeak: row.offPeak };
+        const revisions = schedules.get(row.model);
+        if (revisions === undefined) {
+            schedules.set(row.model, [revision]);
+            continue;
+        }
+        const duplicate = revisions.findIndex(candidate => candidate.effectiveFrom === revision.effectiveFrom);
+        if (duplicate >= 0)
+            revisions[duplicate] = revision;
+        else
+            revisions.push(revision);
+    }
     const models = new Map();
-    for (const row of rows)
-        models.set(row.model, { peak: row.peak, offPeak: row.offPeak });
+    for (const [model, revisions] of schedules) {
+        revisions.sort((left, right) => (left.effectiveFrom ?? Number.NEGATIVE_INFINITY) - (right.effectiveFrom ?? Number.NEGATIVE_INFINITY));
+        const newest = revisions[revisions.length - 1];
+        models.set(model, { peak: newest.peak, offPeak: newest.offPeak, revisions });
+    }
     return { peakHours, models };
 }
 /**
- * Derive the Beijing hour, weekday, and calendar-day key of one timestamp from
- * a single shifted `Date` — every timezone-sensitive read shares this one
- * implementation, so the pieces cannot drift apart.
+ * The rate revision in effect at one instant: the newest revision that took
+ * effect at or before it. Revisions are ascending, so the scan stops at the
+ * first future one. An instant before the earliest dated revision bills at that
+ * earliest revision — a model with only dated rows is never left unpriced.
+ */
+function ratesAt(revisions, time) {
+    let chosen = revisions[0];
+    for (let index = 1; index < revisions.length; index += 1) {
+        const revision = revisions[index];
+        if (revision.effectiveFrom === undefined || revision.effectiveFrom > time)
+            break;
+        chosen = revision;
+    }
+    return chosen;
+}
+/** Beijing is a fixed UTC+8 offset with no DST. */
+const BEIJING_OFFSET_MS = 8 * 3_600_000;
+/** Milliseconds in one day. */
+const DAY_MS = 86_400_000;
+/** Epoch day of 1970-01-01 in the civil-date algorithm below. */
+const CIVIL_EPOCH_DAY = 719_468;
+/** Two-digit zero pad for a calendar field. */
+function pad2(value) {
+    return value < 10 ? `0${value}` : String(value);
+}
+/**
+ * Civil date of an epoch day (Howard Hinnant's days-from-civil inverse):
+ * pure integer arithmetic, no `Date` allocation and no ISO-string slicing.
+ */
+function civilDateOf(epochDay) {
+    const shifted = epochDay + CIVIL_EPOCH_DAY;
+    const era = Math.floor(shifted / 146_097);
+    const dayOfEra = shifted - era * 146_097;
+    const yearOfEra = Math.floor((dayOfEra - Math.floor(dayOfEra / 1_460) + Math.floor(dayOfEra / 36_524) - Math.floor(dayOfEra / 146_096)) / 365);
+    const year = yearOfEra + era * 400;
+    const dayOfYear = dayOfEra - (365 * yearOfEra + Math.floor(yearOfEra / 4) - Math.floor(yearOfEra / 100));
+    const monthPrime = Math.floor((5 * dayOfYear + 2) / 153);
+    const month = monthPrime + (monthPrime < 10 ? 3 : -9);
+    return {
+        // January/February belong to the civil year AFTER the era year.
+        year: month <= 2 ? year + 1 : year,
+        month,
+        day: dayOfYear - Math.floor((153 * monthPrime + 2) / 5) + 1,
+    };
+}
+/**
+ * Derive the Beijing hour, weekday, and calendar-day key of one timestamp with
+ * pure integer arithmetic — every timezone-sensitive read shares this one
+ * implementation, so the pieces cannot drift apart. Callers that filter by
+ * day and then price the same event reuse the returned view, so each event is
+ * parsed exactly once. (The hot fold path runs this per committed event; the
+ * previous `Date` + `toISOString().slice()` version allocated a `Date` and a
+ * 24-character string per call.)
  * @param time - epoch milliseconds.
+ * @throws {RangeError} when `time` is not a finite number.
  */
-function beijingParts(time) {
-    const shifted = new Date(time + 8 * 3_600_000);
+export function beijingPartsOf(time) {
+    if (!Number.isFinite(time))
+        throw new RangeError(`billing: event time is not finite (${String(time)})`);
+    const shifted = time + BEIJING_OFFSET_MS;
+    const epochDay = Math.floor(shifted / DAY_MS);
+    const msOfDay = shifted - epochDay * DAY_MS;
+    const civil = civilDateOf(epochDay);
     return {
-        hour: shifted.getUTCHours(),
-        weekday: shifted.getUTCDay(),
-        dayKey: shifted.toISOString().slice(0, 10),
+        time,
+        hour: Math.floor(msOfDay / 3_600_000),
+        // 1970-01-01 was a Thursday (4).
+        weekday: ((epochDay + 4) % 7 + 7) % 7,
+        dayKey: `${civil.year}-${pad2(civil.month)}-${pad2(civil.day)}`,
     };
 }
 /** The Beijing (Asia/Shanghai, UTC+8, no DST) calendar-day key of a timestamp. */
 export function beijingDayKey(now) {
-    return beijingParts(now.getTime()).dayKey;
+    return beijingPartsOf(now.getTime()).dayKey;
 }
 /**
  * The durable inherited-prefix boundary of one session: the number of leading
@@ -134,44 +271,73 @@ function isPeakParts(billing, hour, weekday) {
  * @returns true during a weekday peak hour.
  */
 export function isPeak(billing, now) {
-    const { hour, weekday } = beijingParts(now.getTime());
+    const { hour, weekday } = beijingPartsOf(now.getTime());
     return isPeakParts(billing, hour, weekday);
 }
 /**
  * Price one event at the official per-model rates, applying the peak/off-peak
  * table by its Beijing-time hour and weekday (peak windows apply Monday–Friday
- * only; weekends are off-peak). Each `assistant/message` event with usage
+ * only; weekends are off-peak) and the rate revision in effect at its own
+ * timestamp. Each `assistant/message` event with usage
  * contributes cache-hit input, cache-miss input (uncached input plus cache
  * writes), and output (reasoning included) tokens at the rate of its own
- * timestamp; a model with usage but no pricing row contributes nothing (the
- * published table prices only the two V4 rows).
+ * timestamp; a model with usage but no pricing row contributes nothing.
  * @param event - the event to price.
  * @param billing - resolved pricing with peak-hour windows.
  * @param names - model id → display label.
  * @returns the priced contribution, or `undefined` when the event has no priced usage.
  */
 export function priceEvent(event, billing, names) {
+    return priceEventAt(beijingPartsOf(event.time), event, billing, names);
+}
+/**
+ * Price one event at the official per-model rates using a precomputed
+ * Beijing-time view — the day-filtering and pricing of one event share a
+ * single timezone parse (see {@link beijingPartsOf}). Semantics are identical
+ * to {@link priceEvent}.
+ * @param parts - the event's Beijing-time view.
+ * @param event - the event to price.
+ * @param billing - resolved pricing with peak-hour windows.
+ * @param names - model id → display label.
+ * @returns the priced contribution, or `undefined` when the event has no priced usage.
+ */
+export function priceEventAt(parts, event, billing, names) {
     if (event.type !== 'assistant/message')
         return undefined;
     const reported = event.data.usage;
     if (reported === undefined)
         return undefined;
-    const model = event.data.message.source.model;
+    return priceUsage(parts, reported, event.data.message.source.model, billing, names);
+}
+/**
+ * Price one provider-reported usage sample for one model at the rates of the
+ * sample's own Beijing-time hour and weekday — the peak or off-peak price of
+ * the rate revision in effect at the sample's own timestamp (a re-priced series
+ * bills its history at the rates that applied then). `undefined` when the model
+ * has no pricing row.
+ * @param parts - the sample's Beijing-time view.
+ * @param usage - the reported token buckets.
+ * @param model - the wire model id the sample belongs to.
+ * @param billing - resolved pricing with peak-hour windows.
+ * @param names - model id → display label.
+ * @returns the priced contribution, or `undefined` when the model has no rate row.
+ */
+export function priceUsage(parts, usage, model, billing, names) {
     const pricing = billing.models.get(model);
     if (pricing === undefined)
         return undefined;
-    const { hour, weekday, dayKey } = beijingParts(event.time);
-    const peak = isPeakParts(billing, hour, weekday);
-    const price = peak ? pricing.peak : pricing.offPeak;
-    const hit = reported.cacheReadTokens ?? 0;
-    const miss = reported.inputTokens + (reported.cacheWriteTokens ?? 0);
-    const output = reported.outputTokens;
+    const peak = isPeakParts(billing, parts.hour, parts.weekday);
+    const revision = ratesAt(pricing.revisions, parts.time);
+    const price = peak ? revision.peak : revision.offPeak;
+    const hit = usage.cacheReadTokens ?? 0;
+    const miss = usage.inputTokens + (usage.cacheWriteTokens ?? 0);
+    const output = usage.outputTokens;
     const hitCost = (hit * price.cacheHitInput) / 1_000_000;
     const missCost = (miss * price.cacheMissInput) / 1_000_000;
     const outputCost = (output * price.output) / 1_000_000;
     const cost = hitCost + missCost + outputCost;
     return {
-        dayKey,
+        dayKey: parts.dayKey,
         model,
         displayName: names.get(model) ?? model,
         cost,
@@ -244,6 +410,202 @@ export class SpendAccumulator {
         return { total: this.total, models: [...this.rows.values()] };
     }
 }
+/** The additive inverse of one spend (pure): used to replace a priced sample. */
+export function negateSpend(spend) {
+    const negate = (value) => -value;
+    return {
+        total: negate(spend.total),
+        models: spend.models.map(row => ({
+            ...row,
+            cost: negate(row.cost),
+            peakCost: negate(row.peakCost),
+            offPeakCost: negate(row.offPeakCost),
+            cacheHitInputTokens: negate(row.cacheHitInputTokens),
+            cacheMissInputTokens: negate(row.cacheMissInputTokens),
+            outputTokens: negate(row.outputTokens),
+            cacheHitInputCost: negate(row.cacheHitInputCost),
+            cacheMissInputCost: negate(row.cacheMissInputCost),
+            outputCost: negate(row.outputCost),
+        })),
+    };
+}
+/**
+ * Subtract one spend from another (pure). Rows that cancel out completely are
+ * dropped so a replaced sample leaves no zero row behind.
+ * @param target - the spend to subtract from.
+ * @param source - the spend to remove.
+ * @returns the difference.
+ */
+export function subtractSpend(target, source) {
+    const rows = new Map();
+    for (const row of target.models)
+        rows.set(row.model, row);
+    for (const row of source.models) {
+        const existing = rows.get(row.model);
+        if (existing === undefined)
+            continue;
+        const next = mergeModelRows(existing, negateSpend({ total: 0, models: [row] }).models[0]);
+        if (next.cost === 0 && next.cacheHitInputTokens === 0 && next.cacheMissInputTokens === 0 && next.outputTokens === 0) {
+            rows.delete(row.model);
+        }
+        else {
+            rows.set(row.model, next);
+        }
+    }
+    return { total: target.total - source.total, models: [...rows.values()] };
+}
+/** The empty fold state for one fork boundary. */
+export function emptyBillingFoldState(inheritedEventCount = 0) {
+    return {
+        dayKey: '',
+        spend: emptyTodaySpend(),
+        session: emptyTodaySpend(),
+        inheritedEventCount,
+        model: '',
+        last: null,
+    };
+}
+/** Whether an unknown value looks like a provider usage report. */
+function isTokenUsage(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const candidate = value;
+    return typeof candidate.inputTokens === 'number' && typeof candidate.outputTokens === 'number';
+}
+/**
+ * The last `usage` sample embedded in an event's stream, if any. `assistant/
+ * attempt` and the embedded streams are newer than the plugin's npm baseline,
+ * so the stream is read structurally (a failed/retried attempt reports its
+ * usage only there).
+ */
+function streamUsageOf(event) {
+    const stream = event.data === undefined
+        ? undefined
+        : event.data.stream;
+    if (!Array.isArray(stream))
+        return undefined;
+    for (let index = stream.length - 1; index >= 0; index -= 1) {
+        const chunk = stream[index]?.chunk;
+        if (chunk === undefined || chunk.type !== 'usage')
+            continue;
+        return isTokenUsage(chunk.usage) ? chunk.usage : undefined;
+    }
+    return undefined;
+}
+/** The contribution as a one-row spend (the shape a sample keeps for replacement). */
+function contributionSpend(priced) {
+    return { total: priced.cost, models: [contributionModel(priced)] };
+}
+/**
+ * Fold one committed event into a session's billed-spend state.
+ *
+ * Priced samples come from `assistant/message` (its own reported usage, or the
+ * stream's last usage chunk) and `assistant/attempt` (the stream's last usage
+ * chunk, priced with the model of the latest `request/header`, since an
+ * attempt carries no route). A sample for the same `(turn, step)` replaces the
+ * previous one; `llm/retry-started` closes the replacement slot so a retried
+ * attempt adds. Every other event is inert and returns the same state
+ * reference.
+ * @param state - the previous fold state.
+ * @param event - the committed event.
+ * @param billing - resolved pricing with peak-hour windows.
+ * @param names - model id → display label.
+ * @returns the next state (the same reference when nothing was priced).
+ */
+export function applyBillingEvent(state, event, billing, names) {
+    if (event.seq < state.inheritedEventCount)
+        return state;
+    // `assistant/attempt`, `llm/retry-started`, and the embedded stream are all
+    // newer than the npm baseline this package builds against, so their fields
+    // are read structurally.
+    const type = event.type;
+    if (type === 'request/header') {
+        const model = event.data
+            ?.header?.config?.model;
+        return typeof model === 'string' && model.length > 0 && model !== state.model ? { ...state, model } : state;
+    }
+    const data = event.data;
+    if (type === 'llm/retry-started') {
+        if (typeof data?.turn !== 'number' || typeof data.step !== 'number')
+            return state;
+        const last = state.last;
+        if (last === null || last.turn !== data.turn || last.step !== data.step)
+            return state;
+        return { ...state, last: null };
+    }
+    if (type !== 'assistant/message' && type !== 'assistant/attempt')
+        return state;
+    const usage = (type === 'assistant/message' ? data?.usage : undefined) ?? streamUsageOf(event);
+    if (!isTokenUsage(usage))
+        return state;
+    const model = type === 'assistant/message' ? data?.message?.source?.model : state.model;
+    if (typeof model !== 'string' || model.length === 0)
+        return state;
+    const priced = priceUsage(beijingPartsOf(event.time), usage, model, billing, names);
+    if (priced === undefined)
+        return state;
+    let session = state.session;
+    let spend = state.spend;
+    let dayKey = state.dayKey;
+    const last = state.last;
+    const turn = typeof data?.turn === 'number' ? data.turn : 0;
+    const step = typeof data?.step === 'number' ? data.step : 0;
+    if (last !== null && last.turn === turn && last.step === step) {
+        session = subtractSpend(session, last.spend);
+        if (last.dayKey === dayKey)
+            spend = subtractSpend(spend, last.spend);
+    }
+    session = addEventContribution(session, priced);
+    if (dayKey === priced.dayKey) {
+        spend = addEventContribution(spend, priced);
+    }
+    else if (dayKey === '' || priced.dayKey > dayKey) {
+        // The session log is append-only and chronological, so a strictly older
+        // day cannot legally follow; ignore it for the latest-day state (the
+        // whole-session total still accrues).
+        dayKey = priced.dayKey;
+        spend = addEventContribution(emptyTodaySpend(), priced);
+    }
+    return {
+        ...state,
+        dayKey,
+        spend,
+        session,
+        last: { turn, step, dayKey: priced.dayKey, spend: contributionSpend(priced) },
+    };
+}
+/**
+ * Mutable wrapper over {@link applyBillingEvent} for the pure pricing paths:
+ * feed events in order, read the folded spend.
+ */
+export class BillingFolder {
+    billing;
+    state;
+    /**
+     * @param billing - resolved pricing with peak-hour windows.
+     * @param catalog - model display rows, in presentation order.
+     * @param inheritedEventCount - fork boundary to skip (default 0).
+     */
+    constructor(billing, catalog, inheritedEventCount = 0) {
+        this.billing = billing;
+        this.names = new Map(catalog.map(model => [model.id, model.name]));
+        this.state = emptyBillingFoldState(inheritedEventCount);
+    }
+    names;
+    /** Fold one event. */
+    add(event) {
+        this.state = applyBillingEvent(this.state, event, this.billing, this.names);
+    }
+    /** Fold every event, in order. */
+    addAll(events) {
+        for (const event of events)
+            this.add(event);
+    }
+    /** The folded state (live reference; do not mutate). */
+    get fold() {
+        return this.state;
+    }
+}
 /**
  * Merge one priced event's contribution into an accumulator spend (pure:
  * returns a new spend, never mutates its input).
@@ -276,36 +638,11 @@ export function mergeTodaySpend(target, source) {
     return { total: target.total + source.total, models: [...rows.values()] };
 }
 /**
- * Price a set of billed events at the official per-model rates, applying the
- * peak/off-peak table per event by its Beijing-time hour and weekday (peak
- * windows apply Monday–Friday only; weekends are off-peak). Each
- * `assistant/message` event with usage contributes cache-hit input, cache-miss
- * input (uncached input plus cache writes), and output (reasoning included)
- * tokens at the rate of its own timestamp, with the three component costs
- * carried separately; a model with usage but no pricing row is omitted (the
- * published table prices only the two V4 rows).
- * @param events - the events to price.
- * @param billing - resolved pricing with peak-hour windows.
- * @param names - model id → display label.
- * @param dayKey - when provided, only events on this Beijing calendar day contribute.
- * @param startSeq - when provided, only events with `seq >= startSeq` contribute
- *   (a forked session's inherited prefix, `seq < startSeq`, is skipped).
- * @returns the total cost plus one row per priced model.
- */
-function priceEvents(events, billing, names, dayKey, startSeq = 0) {
-    const accumulator = new SpendAccumulator();
-    for (const event of events) {
-        if (event.seq < startSeq)
-            continue;
-        const priced = priceEvent(event, billing, names);
-        if (priced === undefined || (dayKey !== undefined && priced.dayKey !== dayKey))
-            continue;
-        accumulator.add(priced);
-    }
-    return accumulator.finish();
-}
-/**
- * Price one session's complete event log at the official per-model rates.
+ * Price one session's complete event log at the official per-model rates,
+ * with DSH's attempt semantics: every provider-reported sample (an
+ * `assistant/message`'s usage, or an `assistant/attempt`'s stream usage)
+ * contributes, a later sample for the same `(turn, step)` replaces the earlier
+ * one, and `llm/retry-started` makes the retried attempt add.
  * @param events - one session's complete event log.
  * @param billing - resolved pricing with peak-hour windows.
  * @param catalog - model display rows, in presentation order.
@@ -316,17 +653,18 @@ function priceEvents(events, billing, names, dayKey, startSeq = 0) {
  * @returns the session's total cost plus one row per priced model.
  */
 export function computeSessionSpend(events, billing, catalog, startSeq = 0) {
-    const names = new Map(catalog.map(model => [model.id, model.name]));
-    return priceEvents(events, billing, names, undefined, startSeq);
+    const folder = new BillingFolder(billing, catalog, startSeq);
+    folder.addAll(events);
+    return folder.fold.session;
 }
 /**
- * Price one completed Turn's billed usage at the official per-model rates,
- * identified by its closing assistant message id. The turn's events are those
- * between its `turn/start` and `turn/end` (both matched by the message's own
- * turn coordinate); each priced event applies the peak/off-peak table by its
- * Beijing-time hour and weekday. A message that cannot be located, a turn
- * without bracketing `turn/start` / `turn/end` events (for example after
- * compaction), or a session with no priced usage prices to zero.
+ * Price one completed Turn's billed usage, identified by its closing
+ * assistant message id. The turn's events are those between its `turn/start`
+ * and `turn/end` (both matched by the message's own turn coordinate), priced
+ * with the same attempt semantics as {@link computeSessionSpend}. A message
+ * that cannot be located, a turn without bracketing `turn/start` / `turn/end`
+ * events (for example after compaction), or a session with no priced usage
+ * prices to zero.
  * @param events - one session's complete event log.
  * @param billing - resolved pricing with peak-hour windows.
  * @param catalog - model display rows, in presentation order.
@@ -334,7 +672,18 @@ export function computeSessionSpend(events, billing, catalog, startSeq = 0) {
  * @returns the turn's total cost in CNY.
  */
 export function computeTurnSpend(events, billing, catalog, messageId) {
-    const names = new Map(catalog.map(model => [model.id, model.name]));
+    return { total: turnCostOf(events, billing, catalog, messageId) };
+}
+/**
+ * The total cost of the Turn containing `messageId`, folded with the shared
+ * attempt semantics (see {@link applyBillingEvent}).
+ * @param events - one session's complete event log.
+ * @param billing - resolved pricing with peak-hour windows.
+ * @param catalog - model display rows, in presentation order.
+ * @param messageId - one assistant message inside the Turn.
+ * @returns the Turn's total cost in CNY, or 0 when the Turn cannot be located.
+ */
+function turnCostOf(events, billing, catalog, messageId) {
     let turn;
     for (const event of events) {
         if (event.type !== 'assistant/message')
@@ -345,8 +694,8 @@ export function computeTurnSpend(events, billing, catalog, messageId) {
         break;
     }
     if (turn === undefined)
-        return { total: 0 };
-    const accumulator = new SpendAccumulator();
+        return 0;
+    const folder = new BillingFolder(billing, catalog);
     let active = false;
     for (const event of events) {
         if (event.type === 'turn/start' && event.data.turn === turn) {
@@ -357,17 +706,117 @@ export function computeTurnSpend(events, billing, catalog, messageId) {
             break;
         if (!active)
             continue;
-        const priced = priceEvent(event, billing, names);
-        if (priced !== undefined)
-            accumulator.add(priced);
+        folder.add(event);
+    }
+    return folder.fold.session.total;
+}
+/**
+ * Incremental single-pass fold of one session's completed-Turn costs, keyed by
+ * the id of every assistant message inside each Turn. Feeding the fold only
+ * the appended tail keeps a growing session's map current in O(new events)
+ * instead of re-scanning the whole log per message.
+ *
+ * Semantics are exactly {@link computeTurnSpend}'s: a Turn is the
+ * `turn/start`..`turn/end` range (matched by the event's own turn coordinate),
+ * every priced event inside it contributes at its own timestamp's rate, and a
+ * message outside any bracket contributes nothing.
+ */
+export class SessionTurnSpendFolder {
+    billing;
+    catalog;
+    rows = [];
+    ids = [];
+    /** Events of the open Turn, folded with the shared attempt semantics on close. */
+    events = [];
+    open = false;
+    /** Events already fed; a shorter log resets the fold. */
+    cursor = 0;
+    /**
+     * @param billing - resolved pricing with peak-hour windows.
+     * @param catalog - model display rows, in presentation order.
+     */
+    constructor(billing, catalog) {
+        this.billing = billing;
+        this.catalog = catalog;
+    }
+    /** How many events have been folded so far (the host's incremental cursor). */
+    get processed() {
+        return this.cursor;
     }
-    return { total: accumulator.finish().total };
+    /**
+     * Fold every event from the cursor to the end of the log. A log shorter than
+     * the cursor (rewritten session) restarts the fold from an empty state.
+     * @param events - the session's complete event log, in seq order.
+     */
+    feed(events) {
+        if (events.length < this.cursor)
+            this.reset();
+        for (let index = this.cursor; index < events.length; index += 1) {
+            const event = events[index];
+            if (event.type === 'turn/start') {
+                this.open = true;
+                this.ids = [];
+                this.events = [];
+                continue;
+            }
+            if (event.type === 'turn/end') {
+                if (this.open) {
+                    const folder = new BillingFolder(this.billing, this.catalog);
+                    folder.addAll(this.events);
+                    const total = folder.fold.session.total;
+                    for (const messageId of this.ids)
+                        this.rows.push({ messageId, total });
+                }
+                this.open = false;
+                this.ids = [];
+                this.events = [];
+                continue;
+            }
+            if (!this.open)
+                continue;
+            if (event.type === 'assistant/message')
+                this.ids.push(event.data.message.id);
+            this.events.push(event);
+        }
+        this.cursor = events.length;
+    }
+    /** The folded map; the fold stays usable afterwards. */
+    finish() {
+        return { turns: [...this.rows] };
+    }
+    /** Drop the fold state so the next feed starts from the log's beginning. */
+    reset() {
+        this.rows.length = 0;
+        this.ids = [];
+        this.events = [];
+        this.open = false;
+        this.cursor = 0;
+    }
+}
+/**
+ * Price every completed Turn of one session in a single pass (the pure
+ * equivalent of {@link SessionTurnSpendFolder}).
+ * @param events - one session's complete event log.
+ * @param billing - resolved pricing with peak-hour windows.
+ * @param catalog - model display rows, in presentation order.
+ * @returns one row per assistant message inside a completed Turn, in log order.
+ */
+export function computeSessionTurnSpends(events, billing, catalog) {
+    const folder = new SessionTurnSpendFolder(billing, catalog);
+    folder.feed(events);
+    return folder.finish();
 }
 /**
- * Price every event whose Beijing-time calendar day is the day of `now`,
- * aggregating across every session's event log. Events from other Beijing
- * days are ignored, so a caller passes the concatenated logs of all sessions.
- * @param events - every session's complete event log, concatenated.
+ * Price one session's log for the Beijing-time calendar day of `now`. Events
+ * after the reference day are ignored; the fold's latest-day state then
+ * answers the query exactly (empty when the session's latest priced day is not
+ * the reference day). Pricing follows {@link applyBillingEvent} (attempt
+ * samples with same-step replacement).
+ *
+ * The fold's `(turn, step)` replacement slot is per session, so callers must
+ * pass ONE session's log; aggregate across sessions with
+ * {@link mergeTodaySpend}.
+ * @param events - one session's complete event log.
  * @param billing - resolved pricing with peak-hour windows.
  * @param catalog - model display rows, in presentation order.
  * @param now - the reference moment whose Beijing-time calendar day is "today".
@@ -375,7 +824,13 @@ export function computeTurnSpend(events, billing, catalog, messageId) {
  */
 export function computeTodaySpend(events, billing, catalog, now = new Date()) {
     const day = beijingDayKey(now);
-    const names = new Map(catalog.map(model => [model.id, model.name]));
-    return priceEvents(events, billing, names, day);
+    const folder = new BillingFolder(billing, catalog);
+    for (const event of events) {
+        // Only events up to the reference day can contribute.
+        if (beijingPartsOf(event.time).dayKey > day)
+            continue;
+        folder.add(event);
+    }
+    return folder.fold.dayKey === day ? folder.fold.spend : emptyTodaySpend();
 }
 //# sourceMappingURL=billing.js.map