@rayadesu/dsh-llm-billing 0.3.7 → 0.3.9

package/lib/types/billing.js

@@ -28,6 +28,14 @@ export const DEFAULT_MODEL_PRICING = [
         peak: { cacheHitInput: 0.10, cacheMissInput: 3.0, output: 9.0 },
         offPeak: { cacheHitInput: 0.05, cacheMissInput: 1.5, output: 4.5 },
     },
+    // deepseek-v4.1-flash-expires-on-0910 bills at the same rates as
+    // deepseek-v4-flash; image inputs are converted to tokens at the same
+    // per-token price.
+    {
+        model: 'deepseek-v4.1-flash-expires-on-0910',
+        peak: { cacheHitInput: 0.10, cacheMissInput: 3.0, output: 9.0 },
+        offPeak: { cacheHitInput: 0.05, cacheMissInput: 1.5, output: 4.5 },
+    },
     {
         model: 'deepseek-v4-pro',
         peak: { cacheHitInput: 0.30, cacheMissInput: 9.0, output: 27.0 },
@@ -40,6 +48,17 @@ export const DEFAULT_MODEL_PRICING = [
         peak: { cacheHitInput: 0.10, cacheMissInput: 3.0, output: 9.0 },
         offPeak: { cacheHitInput: 0.05, cacheMissInput: 1.5, output: 4.5 },
     },
+    // MiMo-V2.5 series (Xiaomi): flat rate, no peak/off-peak distinction.
+    {
+        model: 'mimo-v2.5-pro',
+        peak: { cacheHitInput: 0.025, cacheMissInput: 3.0, output: 6.0 },
+        offPeak: { cacheHitInput: 0.025, cacheMissInput: 3.0, output: 6.0 },
+    },
+    {
+        model: 'mimo-v2.5',
+        peak: { cacheHitInput: 0.02, cacheMissInput: 1.0, output: 2.0 },
+        offPeak: { cacheHitInput: 0.02, cacheMissInput: 1.0, output: 2.0 },
+    },
 ];
 /**
  * Resolve optional configuration to a pricing table, defaulting omitted or
@@ -62,23 +81,64 @@ export function resolveBilling(config) {
         models.set(row.model, { peak: row.peak, offPeak: row.offPeak });
     return { peakHours, models };
 }
+/** 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);
+}
 /**
- * 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.
+ * 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),
+        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
@@ -123,7 +183,7 @@ 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);
 }
 /**
@@ -132,35 +192,60 @@ export function isPeak(billing, now) {
  * 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; 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. `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 peak = isPeakParts(billing, parts.hour, parts.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 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,
@@ -233,6 +318,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).
@@ -265,36 +546,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.
@@ -305,17 +561,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.
@@ -323,7 +580,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')
@@ -334,8 +602,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) {
@@ -346,17 +614,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;
+    }
+    /**
+     * 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;
     }
-    return { total: accumulator.finish().total };
+    /** 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".
@@ -364,7 +732,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

package/lib/types/index.d.ts

@@ -24,8 +24,8 @@ import type { Context } from '@deepseek-ai/cordis';
 import z from '@deepseek-ai/schemastery';
 import type { BillingConfig } from './billing.ts';
 export { DeepSeekBalanceGateway, fetchDeepSeekBalance, parseDeepSeekBalance } from './balance.ts';
-export { addEventContribution, beijingDayKey, computeSessionSpend, computeTodaySpend, computeTurnSpend, DEFAULT_MODEL_PRICING, DEFAULT_PEAK_HOURS, emptyTodaySpend, forkBoundaryOf, isPeak, isSeededSession, mergeTodaySpend, priceEvent, resolveBilling, SpendAccumulator, } from './billing.ts';
-export type { BillingConfig, BillingConfigModel, BillingEventContribution, DeepSeekModelPricing, DeepSeekTokenPrice, PeakHourWindow, ResolvedBilling, } from './billing.ts';
+export { addEventContribution, applyBillingEvent, beijingDayKey, BillingFolder, computeSessionSpend, computeSessionTurnSpends, computeTodaySpend, computeTurnSpend, DEFAULT_MODEL_PRICING, DEFAULT_PEAK_HOURS, emptyBillingFoldState, emptyTodaySpend, forkBoundaryOf, isPeak, isSeededSession, mergeTodaySpend, negateSpend, priceEvent, priceUsage, resolveBilling, SessionTurnSpendFolder, SpendAccumulator, subtractSpend, } from './billing.ts';
+export type { BillingConfig, BillingConfigModel, BillingEventContribution, BillingFoldSample, BillingFoldState, DeepSeekModelPricing, DeepSeekTokenPrice, PeakHourWindow, ResolvedBilling, } from './billing.ts';
 export type * from './types.ts';
 export { BILLING_UNIT_KEY, billingTodaySpendDefinition, foldBillingUnit, foldOwnBilling } from './projection.ts';
 export type { BillingUnitFold, BillingUnitState } from './projection.ts';
@@ -52,7 +52,7 @@ export interface Config {
     apiKeyEnv?: string;
     /** Endpoint base; defaults to `$DEEPSEEK_BASE_URL`, then `https://api.deepseek.com`. */
     baseURL?: string;
-    /** Advisory display rows, in presentation order; defaults to V4 Flash, V4 Pro, and V4 Flash Vision Exp. */
+    /** Advisory display rows, in presentation order; defaults to V4 Flash, V4.1 Flash, V4 Pro, and V4 Flash Vision Exp. */
     models?: BillingModel[];
     /** Pricing table and peak-hour windows; omission uses the published defaults. Peak windows apply weekdays (Monday–Friday) only; weekends are always off-peak. */
     billing?: BillingConfig;
@@ -62,8 +62,18 @@ export declare const Config: z<Config>;
 export declare const TODAY_SPEND_CACHE_MS = 60000;
 /** Hard cap on today's events collected by the events scan path. */
 export declare const TODAY_SPEND_MAX_EVENTS = 200000;
+/** Max session-spend rows kept for incremental recompute before eviction. */
+export declare const SESSION_SPEND_CACHE_LIMIT = 1024;
+/** Max session-id entries kept in the per-turn-cost fold cache before eviction. */
+export declare const SESSION_TURN_SPEND_CACHE_LIMIT = 64;
+/** How long one balance snapshot is reused before the host refetches it (15s). */
+export declare const BALANCE_CACHE_MS = 15000;
+/** Hard cap on one `/user/balance` request (5s); a hung endpoint never blocks the badge. */
+export declare const BALANCE_TIMEOUT_MS = 5000;
 /**
- * Register the `billing` Remote under the `billing` namespace.
+ * Register the `billing` Remote under the `billing` namespace. Assembly only:
+ * facts resolve once, each loader owns its caches, and the gateway receives
+ * the bound thunks.
  * @param ctx - owning plugin context.
  * @param config - validated plugin config.
  */