@rayadesu/dsh-llm-billing 0.1.0 → 0.2.0

package/lib/types/index.js

@@ -4,6 +4,15 @@
  * the credential/environment seams, prices each session's billed usage with the
  * peak/off-peak table, and exposes the `billing` Remote (`getBalance`, the
  * per-session `getSessionSpend`, and the all-sessions `getTodaySpend`).
+ *
+ * Today's spend never scans every session log per request: a 60-second
+ * Beijing-day cache with in-flight coalescing serves the message-triggered
+ * reads, the manual refresh may bypass the time window (`force`), and the
+ * computation behind a miss reads only sessions whose persisted revision
+ * changed since the last resolution (see today-spend.ts). When the
+ * session-projection registry is composed, the plugin additionally registers
+ * the `billingTodaySpend` projection unit, which folds each session's spend
+ * eagerly and lets cold reads ride the projection-cache ladder.
  * @module @rayadesu/dsh-llm-billing
  */
 import z from '@deepseek-ai/schemastery';
@@ -11,9 +20,13 @@ import { assertUsableApiKey, LlmError } from '@deepseek-ai/dsh-llm';
 import { credentialRef } from '@deepseek-ai/dsh-credentials';
 import { launchEnvironmentOf } from '@deepseek-ai/dsh-launch-environment';
 import { DeepSeekBalanceGateway, fetchDeepSeekBalance } from "./balance.js";
-import { computeSessionSpend, computeTodaySpend, DEFAULT_MODEL_PRICING, DEFAULT_PEAK_HOURS, resolveBilling, } from "./billing.js";
+import { computeSessionSpend, DEFAULT_MODEL_PRICING, DEFAULT_PEAK_HOURS, resolveBilling, } from "./billing.js";
+import { billingTodaySpendDefinition } from "./projection.js";
+import { TodaySpendCache, TodaySpendScanner } from "./today-spend.js";
 export { DeepSeekBalanceGateway, fetchDeepSeekBalance, parseDeepSeekBalance } from "./balance.js";
-export { computeSessionSpend, computeTodaySpend, DEFAULT_MODEL_PRICING, DEFAULT_PEAK_HOURS, isPeak, resolveBilling, } from "./billing.js";
+export { addEventContribution, beijingDayKey, computeSessionSpend, computeTodaySpend, DEFAULT_MODEL_PRICING, DEFAULT_PEAK_HOURS, emptyTodaySpend, isPeak, mergeTodaySpend, priceEvent, resolveBilling, } from "./billing.js";
+export { BILLING_UNIT_KEY, billingTodaySpendDefinition, foldBillingUnit } from "./projection.js";
+export { TodaySpendCache, TodaySpendScanner } from "./today-spend.js";
 export const name = 'llm-billing';
 const DEFAULT_API_KEY_ENV = 'DEEPSEEK_API_KEY';
 const BASE_URL_ENV = 'DEEPSEEK_BASE_URL';
@@ -50,9 +63,14 @@ export const Config = z.object({
     models: z.array(billingModel).default(DEFAULT_MODELS),
     billing: billingConfig,
 });
+/** How often a Beijing-day "today spend" value may be recomputed (60s). */
+export const TODAY_SPEND_CACHE_MS = 60_000;
+/** Hard cap on today's events collected by the events scan path. */
+export const TODAY_SPEND_MAX_EVENTS = 200_000;
 /**
  * Read one session's event log: the live SessionStore first, then the
- * persistence backend for a flushed session.
+ * persistence backend for a flushed session (inspected directly by id — no
+ * header listing).
  * @param ctx - plugin context carrying the SessionStore and optional persistence.
  * @param sessionId - the session to read.
  * @returns the session's complete event log.
@@ -65,52 +83,14 @@ async function sessionEvents(ctx, sessionId) {
         return live.events;
     const persistence = ctx.get('sessionPersistence');
     if (persistence !== undefined) {
-        for (const header of await persistence.list()) {
-            if (header.id !== sessionId)
-                continue;
-            const inspection = await persistence.inspect(sessionId);
-            return inspection.events;
+        try {
+            return (await persistence.inspect(sessionId)).events;
         }
-    }
-    throw new LlmError(`llm-billing: session ${sessionId} not found`, 'NOT_FOUND');
-}
-/**
- * Read every session's event log, concatenated: each live SessionStore
- * session first (its log may hold events not yet flushed), then each persisted
- * session that is not live, so no event is counted twice. Events are appended
- * one at a time: spreading a very large log into `push(...)` exceeds the
- * engine's argument limit and throws a stack RangeError.
- * @param ctx - plugin context carrying the SessionStore and optional persistence.
- * @returns every session's complete event log, concatenated.
- */
-async function allSessionEvents(ctx) {
-    const events = [];
-    const sessions = ctx.get('sessions');
-    const liveIds = new Set();
-    if (sessions !== undefined) {
-        for (const session of sessions.list()) {
-            liveIds.add(session.id);
-            for (const event of session.events)
-                events.push(event);
+        catch (error) {
+            throw new LlmError(`llm-billing: session ${sessionId} not found`, 'NOT_FOUND', { cause: error });
         }
     }
-    const persistence = ctx.get('sessionPersistence');
-    if (persistence !== undefined) {
-        for (const header of await persistence.list()) {
-            if (liveIds.has(header.id))
-                continue;
-            try {
-                const inspection = await persistence.inspect(header.id);
-                for (const event of inspection.events)
-                    events.push(event);
-            }
-            catch (error) {
-                // One unreadable session must not blank the whole-day aggregate.
-                ctx.logger.warn(`llm-billing: skipping unreadable session ${header.id}: ${String(error)}`);
-            }
-        }
-    }
-    return events;
+    throw new LlmError(`llm-billing: session ${sessionId} not found`, 'NOT_FOUND');
 }
 /**
  * Register the `billing` Remote under the `billing` namespace.
@@ -141,16 +121,46 @@ export function apply(ctx, config) {
         const apiKey = await resolveApiKey();
         return fetchDeepSeekBalance(baseURL(), apiKey);
     };
+    const billing = resolveBilling(config.billing);
+    const catalog = (config.models ?? DEFAULT_MODELS).map(model => ({ id: model.id, name: model.name ?? model.id }));
     const fetchSessionSpend = async (sessionId) => {
-        const billing = resolveBilling(config.billing);
-        const catalog = (config.models ?? DEFAULT_MODELS).map(model => ({ id: model.id, name: model.name ?? model.id }));
         return computeSessionSpend(await sessionEvents(ctx, sessionId), billing, catalog);
     };
-    const fetchTodaySpend = async () => {
-        const billing = resolveBilling(config.billing);
-        const catalog = (config.models ?? DEFAULT_MODELS).map(model => ({ id: model.id, name: model.name ?? model.id }));
-        return computeTodaySpend(await allSessionEvents(ctx), billing, catalog);
+    // Plan C: register the per-session spend projection unit on the projection
+    // registry. Registration is lazy — it happens on the first projection-path
+    // scan, not through `ctx.inject` (whose plugin-mount wait would also engage
+    // the test-invariant host in suites that never provide the registry). The
+    // registry builds cells lazily over the in-memory log, so events committed
+    // before registration are folded on first touch; without the registry the
+    // events path serves today's spend.
+    const unit = billingTodaySpendDefinition(billing, catalog);
+    let unitRegistered = false;
+    const ensureUnit = () => {
+        if (unitRegistered)
+            return;
+        const registry = ctx.get('sessionProjections');
+        if (registry === undefined)
+            return;
+        registry.register(unit);
+        unitRegistered = true;
     };
+    // Plans A1–A3: 60s Beijing-day cache with in-flight coalescing and a force
+    // bypass, over a revision-gated scanner (projection path when the registry
+    // is composed, events path otherwise).
+    const scanner = new TodaySpendScanner({
+        sessions: () => ctx.get('sessions'),
+        persistence: () => ctx.get('sessionPersistence'),
+        projections: () => ctx.get('sessionProjections'),
+        projectionCache: () => ctx.get('sessionProjectionCache'),
+        ensureUnit,
+        unit,
+        maxEvents: TODAY_SPEND_MAX_EVENTS,
+        logger: ctx.logger,
+        billing,
+        catalog,
+    });
+    const todayCache = new TodaySpendCache(dayKey => scanner.scan(dayKey), TODAY_SPEND_CACHE_MS);
+    const fetchTodaySpend = async (force = false) => todayCache.get(force);
     new DeepSeekBalanceGateway(ctx, { fetchBalance, fetchSessionSpend, fetchTodaySpend });
 }
 //# sourceMappingURL=index.js.map

package/lib/types/projection.d.ts

@@ -0,0 +1,69 @@
+/**
+ * `billingTodaySpend` session-projection unit: per-session, per-Beijing-day
+ * billed spend, folded eagerly by the DSH projection drive over committed
+ * session events and checkpointed by the projection cache. The unit keeps only
+ * the spend of the session's LATEST priced day (events are append-only and
+ * chronological, so a day strictly older than the state's day never returns);
+ * the aggregate "today" read sums the units whose `dayKey` matches the current
+ * Beijing day — zero full-log scans once the fold is warm.
+ *
+ * The unit's fold shares {@link priceEvent} with the events-scan paths
+ * (`computeTodaySpend`), so both price with the same table. The unit is
+ * client-visible (`wire` = identity) because the persisted-cache read ladder
+ * (`sessionProjectionCache.coldSnapshot` / registry `restore`) serves only
+ * wired units; the wire value is the state itself.
+ * @module @rayadesu/dsh-llm-billing/projection
+ */
+import type { ProjectionDefinition } from '@deepseek-ai/dsh-session-projection';
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
+import type { ResolvedBilling } from './billing.ts';
+import type { DeepSeekTodaySpend } from './types.ts';
+/** The projection key this unit owns. */
+export declare const BILLING_UNIT_KEY = "billingTodaySpend";
+/**
+ * Per-session unit state: the Beijing day of the session's latest priced
+ * event and that day's billed spend. `dayKey` is `''` while the session has no
+ * priced usage, and the state only ever describes ONE day (the latest) —
+ * plain JSON, as the persisted-cache contract requires.
+ */
+export interface BillingUnitState {
+    /** Beijing-time calendar-day key of the state's spend; `''` for no priced usage. */
+    dayKey: string;
+    /** The spend of the session's latest priced Beijing day. */
+    spend: DeepSeekTodaySpend;
+}
+declare module '@deepseek-ai/dsh-session-projection/types' {
+    interface SessionProjectionStateMap {
+        billingTodaySpend: BillingUnitState;
+    }
+    interface SessionProjectionMap {
+        billingTodaySpend: BillingUnitState;
+    }
+}
+/**
+ * The unit definition with a required `wire` — the shape {@link register}
+ * accepts for a client-visible unit (the plain `ProjectionDefinition` type
+ * leaves `wire` optional).
+ */
+export type BillingUnitDefinition = Omit<ProjectionDefinition<'billingTodaySpend', BillingUnitState>, 'wire'> & {
+    wire: NonNullable<ProjectionDefinition<'billingTodaySpend', BillingUnitState>['wire']>;
+};
+/**
+ * Build the `billingTodaySpend` unit for one resolved pricing table. The
+ * pricing closure is fixed at registration; a pricing-table change therefore
+ * prices only events folded after the change (historical spend keeps its
+ * historical rates), unlike the events-scan paths which re-price the whole
+ * log. Bump {@link ProjectionDefinition.stateVersion} whenever the state
+ * shape or fold semantics change, so persisted checkpoint rows are discarded
+ * instead of folded forward.
+ * @param billing - resolved pricing with peak-hour windows.
+ * @param catalog - model display rows, in presentation order.
+ * @returns the unit definition to register on `ctx.sessionProjections`.
+ */
+export declare function billingTodaySpendDefinition(billing: ResolvedBilling, catalog: readonly {
+    id: string;
+    name: string;
+}[]): BillingUnitDefinition;
+/** Fold a unit from init over one session's event log (the detached cold recipe). */
+export declare function foldBillingUnit(unit: Pick<ProjectionDefinition<'billingTodaySpend', BillingUnitState>, 'init' | 'apply'>, events: readonly SessionEvent[]): BillingUnitState;
+//# sourceMappingURL=projection.d.ts.map

package/lib/types/projection.js

@@ -0,0 +1,88 @@
+/**
+ * `billingTodaySpend` session-projection unit: per-session, per-Beijing-day
+ * billed spend, folded eagerly by the DSH projection drive over committed
+ * session events and checkpointed by the projection cache. The unit keeps only
+ * the spend of the session's LATEST priced day (events are append-only and
+ * chronological, so a day strictly older than the state's day never returns);
+ * the aggregate "today" read sums the units whose `dayKey` matches the current
+ * Beijing day — zero full-log scans once the fold is warm.
+ *
+ * The unit's fold shares {@link priceEvent} with the events-scan paths
+ * (`computeTodaySpend`), so both price with the same table. The unit is
+ * client-visible (`wire` = identity) because the persisted-cache read ladder
+ * (`sessionProjectionCache.coldSnapshot` / registry `restore`) serves only
+ * wired units; the wire value is the state itself.
+ * @module @rayadesu/dsh-llm-billing/projection
+ */
+import { z } from 'zod';
+import { addEventContribution, emptyTodaySpend, priceEvent } from "./billing.js";
+/** The projection key this unit owns. */
+export const BILLING_UNIT_KEY = 'billingTodaySpend';
+const modelRowSchema = z.object({
+    model: z.string(),
+    displayName: z.string(),
+    cost: z.number().nonnegative(),
+    peakCost: z.number().nonnegative(),
+    offPeakCost: z.number().nonnegative(),
+    cacheHitInputTokens: z.number().int().nonnegative(),
+    cacheMissInputTokens: z.number().int().nonnegative(),
+    outputTokens: z.number().int().nonnegative(),
+    cacheHitInputCost: z.number().nonnegative(),
+    cacheMissInputCost: z.number().nonnegative(),
+    outputCost: z.number().nonnegative(),
+}).strict();
+const todaySpendSchema = z.object({
+    total: z.number().nonnegative(),
+    models: z.array(modelRowSchema),
+}).strict();
+const billingUnitSchema = z.object({
+    dayKey: z.string(),
+    spend: todaySpendSchema,
+}).strict();
+/**
+ * Build the `billingTodaySpend` unit for one resolved pricing table. The
+ * pricing closure is fixed at registration; a pricing-table change therefore
+ * prices only events folded after the change (historical spend keeps its
+ * historical rates), unlike the events-scan paths which re-price the whole
+ * log. Bump {@link ProjectionDefinition.stateVersion} whenever the state
+ * shape or fold semantics change, so persisted checkpoint rows are discarded
+ * instead of folded forward.
+ * @param billing - resolved pricing with peak-hour windows.
+ * @param catalog - model display rows, in presentation order.
+ * @returns the unit definition to register on `ctx.sessionProjections`.
+ */
+export function billingTodaySpendDefinition(billing, catalog) {
+    const names = new Map(catalog.map(model => [model.id, model.name]));
+    return {
+        key: BILLING_UNIT_KEY,
+        stateVersion: 1,
+        stateSchema: billingUnitSchema,
+        init: () => ({ dayKey: '', spend: emptyTodaySpend() }),
+        apply: (state, event) => {
+            const priced = priceEvent(event, billing, names);
+            if (priced === undefined)
+                return state;
+            if (state.dayKey === priced.dayKey) {
+                return { dayKey: state.dayKey, spend: addEventContribution(state.spend, priced) };
+            }
+            // The session log is append-only and chronological, so an event whose
+            // Beijing day is strictly older than the state's day cannot legally
+            // follow it; ignore defensively to keep the persisted fold
+            // deterministic under reordered or clock-skewed timestamps.
+            if (state.dayKey !== '' && priced.dayKey < state.dayKey)
+                return state;
+            // First priced event, or the session's first priced event of a new day:
+            // the state resets to that day's spend.
+            return { dayKey: priced.dayKey, spend: addEventContribution(emptyTodaySpend(), priced) };
+        },
+        wire: { viewSchema: billingUnitSchema, view: state => state },
+    };
+}
+/** Fold a unit from init over one session's event log (the detached cold recipe). */
+export function foldBillingUnit(unit, events) {
+    let state = unit.init();
+    for (const event of events)
+        state = unit.apply(state, event);
+    return state;
+}
+//# sourceMappingURL=projection.js.map

package/lib/types/today-spend.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Today-spend read path: the 60-second Beijing-day cache with in-flight
+ * coalescing and a force bypass (plan A1), plus the two scan strategies that
+ * compute the aggregate behind a cache miss:
+ *
+ * - projection path (plan C): live sessions read their eagerly folded
+ *   `billingTodaySpend` projection cell; cold sessions resolve through the
+ *   projection-cache ladder (cached row + tail replay + registry restore,
+ *   with write-back) or, without the cache service, one detached local fold
+ *   over a full `inspect`. Persisted revisions gate every cold read, so a
+ *   session whose log did not change since the last resolution costs nothing.
+ * - events path (plans A2/A3): collect only today's events (per-event
+ *   Beijing-day filter during collection) with a hard cap, skipping sessions
+ *   whose persisted revision is unchanged since the last scan.
+ *
+ * Both strategies run behind the same {@link TodaySpendCache}, so a miss
+ * happens at most once per 60 seconds per process, and a manual refresh
+ * (`force`) bypasses the time window but keeps the revision caches — an
+ * unchanged log provably cannot change the aggregate.
+ * @module @rayadesu/dsh-llm-billing/today-spend
+ */
+import type { SessionEvent, SessionId } from '@deepseek-ai/dsh-session';
+import type { SessionPersistenceRevision } from '@deepseek-ai/dsh-session-persistence';
+import type { ResolvedBilling } from './billing.ts';
+import type { DeepSeekTodaySpend } from './types.ts';
+import { BILLING_UNIT_KEY, type BillingUnitState } from './projection.ts';
+import type { ProjectionDefinition } from '@deepseek-ai/dsh-session-projection';
+/** Structural slice of a live session the scanner reads. */
+export interface ScannerSession {
+    readonly id: SessionId;
+    readonly events: readonly SessionEvent[];
+}
+/** Structural slice of a listed persisted session. */
+export interface ScannerPersistedHeader {
+    readonly id: SessionId;
+}
+/** Structural slices of the optional services the scanner reads through. */
+export interface TodaySpendScannerDeps {
+    /** Resolves the live SessionStore at scan time (absent in headless assemblies). */
+    sessions?: () => {
+        list(): readonly ScannerSession[];
+    } | undefined;
+    /** Resolves the persistence backend at scan time (absent without persistence). */
+    persistence?: () => {
+        listSnapshots(): Promise<readonly {
+            header: ScannerPersistedHeader;
+            revision: SessionPersistenceRevision;
+        }[]>;
+        inspect(id: SessionId): Promise<{
+            events: readonly SessionEvent[];
+        }>;
+    } | undefined;
+    /** Resolves the session-projection registry at scan time (absent → events path). */
+    projections?: () => {
+        stateOf(session: ScannerSession, key: typeof BILLING_UNIT_KEY): BillingUnitState | undefined;
+    } | undefined;
+    /** Resolves the projection cache at scan time (absent → detached fold for cold sessions). */
+    projectionCache?: () => {
+        coldSnapshot(id: SessionId): Promise<{
+            values: Partial<Record<typeof BILLING_UNIT_KEY, BillingUnitState>>;
+        }>;
+    } | undefined;
+    /**
+     * Registers the billing unit on the projection registry, called once before
+     * the first projection-path scan. The registry builds cells lazily over the
+     * in-memory log, so events committed before registration are folded on
+     * first touch — late registration is safe by design.
+     */
+    ensureUnit?: () => void;
+    /** The billing unit's fold (the projection path's detached cold recipe). */
+    unit: Pick<ProjectionDefinition<'billingTodaySpend', BillingUnitState>, 'init' | 'apply'>;
+    /** Hard cap on today's events collected by the events path. */
+    maxEvents: number;
+    /** Warn sink for truncation and unreadable sessions. */
+    logger: {
+        warn(message: string): void;
+    };
+    /** Pricing table resolved from the plugin config. */
+    billing: ResolvedBilling;
+    /** Model display rows, in presentation order. */
+    catalog: readonly {
+        id: string;
+        name: string;
+    }[];
+}
+/**
+ * The A1 cache: one Beijing-day key + a 60s window, an in-flight promise that
+ * coalesces concurrent misses, and a `force` bypass for the manual refresh
+ * path. Cross-day invalidation is automatic (the day key changes); a failed
+ * scan leaves the previous value in place and retries on the next call.
+ */
+export declare class TodaySpendCache {
+    private readonly scan;
+    private readonly ttlMs;
+    private readonly now;
+    private cachedDayKey;
+    private cachedValue;
+    private cachedAt;
+    private inFlight;
+    /**
+     * @param ttlMs - time window in milliseconds (default 60 000).
+     * @param now - clock source (injectable for tests).
+     * @param scan - the aggregate computation behind a miss.
+     */
+    constructor(scan: (dayKey: string) => Promise<DeepSeekTodaySpend>, ttlMs?: number, now?: () => Date);
+    /**
+     * Read today's spend, cached per Beijing day within the TTL window.
+     * @param force - bypass the time window (manual refresh); the day-key gate
+     *   and the in-flight coalescing still apply to non-force callers.
+     * @returns today's spend.
+     */
+    get(force?: boolean): Promise<DeepSeekTodaySpend>;
+}
+/**
+ * The aggregate computation behind a cache miss. Chooses the projection path
+ * when the projection registry is composed, the events path otherwise; both
+ * gate cold reads on persisted revisions so steady-state scans touch only
+ * sessions whose logs actually changed.
+ */
+export declare class TodaySpendScanner {
+    private readonly deps;
+    /** Cold sessions resolved on the projection path: id → revision + unit state. */
+    private readonly coldResolved;
+    /** Cold sessions resolved on the events path: id → revision (events were collected). */
+    private lastEventsScan;
+    constructor(deps: TodaySpendScannerDeps);
+    /**
+     * Compute today's aggregate for one Beijing day.
+     * @param dayKey - the Beijing-time calendar-day key to aggregate.
+     * @returns today's spend across every session.
+     */
+    scan(dayKey: string): Promise<DeepSeekTodaySpend>;
+    /** Projection path: eager cells for live sessions, revision-gated cold ladder for the rest. */
+    private scanProjections;
+    /** Events path: collect only today's events (capped), gated by revisions. */
+    private scanEvents;
+}
+//# sourceMappingURL=today-spend.d.ts.map