@rayadesu/dsh-llm-billing 0.2.1 → 0.2.2

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

package/lib/types/today-spend.js

@@ -0,0 +1,246 @@
+/**
+ * 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 { beijingDayKey, computeTodaySpend, emptyTodaySpend, mergeTodaySpend } from "./billing.js";
+import { BILLING_UNIT_KEY, foldBillingUnit } from "./projection.js";
+/** Bounded parallel fan-out: run `run` over `items` with at most `limit` in flight. */
+async function withConcurrency(items, limit, run) {
+    const queue = [...items];
+    await Promise.all(Array.from({ length: Math.min(limit, queue.length) }, async () => {
+        for (let job = queue.shift(); job !== undefined; job = queue.shift())
+            await run(job);
+    }));
+}
+/**
+ * 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 class TodaySpendCache {
+    scan;
+    ttlMs;
+    now;
+    cachedDayKey;
+    cachedValue;
+    cachedAt = 0;
+    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, ttlMs = 60_000, now = () => new Date()) {
+        this.scan = scan;
+        this.ttlMs = ttlMs;
+        this.now = now;
+    }
+    /**
+     * 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 = false) {
+        const now = this.now();
+        const dayKey = beijingDayKey(now);
+        if (!force && this.cachedDayKey === dayKey && this.cachedValue !== undefined
+            && now.getTime() - this.cachedAt < this.ttlMs) {
+            return Promise.resolve(this.cachedValue);
+        }
+        if (!force && this.inFlight !== undefined)
+            return this.inFlight;
+        const run = (async () => {
+            try {
+                const value = await this.scan(dayKey);
+                this.cachedDayKey = dayKey;
+                this.cachedValue = value;
+                this.cachedAt = now.getTime();
+                return value;
+            }
+            finally {
+                this.inFlight = undefined;
+            }
+        })();
+        if (!force)
+            this.inFlight = run;
+        return run;
+    }
+}
+/**
+ * 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 class TodaySpendScanner {
+    deps;
+    /** Cold sessions resolved on the projection path: id → revision + unit state. */
+    coldResolved = new Map();
+    /** Cold sessions resolved on the events path: id → revision (events were collected). */
+    lastEventsScan;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /**
+     * 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.
+     */
+    async scan(dayKey) {
+        if (this.deps.projections?.() === undefined)
+            return this.scanEvents(dayKey);
+        this.deps.ensureUnit?.();
+        return this.scanProjections(dayKey);
+    }
+    /** Projection path: eager cells for live sessions, revision-gated cold ladder for the rest. */
+    async scanProjections(dayKey) {
+        const { sessions, persistence, projections, projectionCache, unit, logger } = this.deps;
+        let total = emptyTodaySpend();
+        const liveIds = new Set();
+        if (sessions !== undefined) {
+            const store = sessions();
+            if (store !== undefined) {
+                for (const session of store.list()) {
+                    liveIds.add(session.id);
+                    const state = projections?.()?.stateOf(session, BILLING_UNIT_KEY);
+                    if (state !== undefined && state.dayKey === dayKey) {
+                        total = mergeTodaySpend(total, state.spend);
+                    }
+                }
+            }
+        }
+        const persistenceService = persistence?.();
+        if (persistenceService === undefined)
+            return total;
+        const snapshots = await persistenceService.listSnapshots();
+        const pending = [];
+        for (const { header, revision } of snapshots) {
+            if (liveIds.has(header.id))
+                continue;
+            const resolved = this.coldResolved.get(header.id);
+            if (resolved !== undefined && resolved.revision === revision) {
+                if (resolved.value.dayKey === dayKey)
+                    total = mergeTodaySpend(total, resolved.value.spend);
+                continue;
+            }
+            pending.push({ id: header.id, revision });
+        }
+        await withConcurrency(pending, 8, async ({ id, revision }) => {
+            let value;
+            const cache = projectionCache?.();
+            if (cache !== undefined) {
+                try {
+                    value = (await cache.coldSnapshot(id)).values[BILLING_UNIT_KEY];
+                }
+                catch (error) {
+                    logger.warn(`llm-billing: projection cold read for session ${id} failed: ${String(error)}`);
+                }
+            }
+            if (value === undefined) {
+                try {
+                    const inspection = await persistenceService.inspect(id);
+                    value = foldBillingUnit(unit, inspection.events);
+                }
+                catch (error) {
+                    // One unreadable session must not blank the whole-day aggregate.
+                    logger.warn(`llm-billing: skipping unreadable session ${id}: ${String(error)}`);
+                }
+            }
+            if (value !== undefined)
+                this.coldResolved.set(id, { revision, value });
+        });
+        for (const { id } of pending) {
+            const resolved = this.coldResolved.get(id);
+            if (resolved !== undefined && resolved.value.dayKey === dayKey) {
+                total = mergeTodaySpend(total, resolved.value.spend);
+            }
+        }
+        return total;
+    }
+    /** Events path: collect only today's events (capped), gated by revisions. */
+    async scanEvents(dayKey) {
+        const { sessions, persistence, maxEvents, logger, billing, catalog } = this.deps;
+        const events = [];
+        const liveIds = new Set();
+        let truncated = false;
+        if (sessions !== undefined) {
+            const store = sessions();
+            if (store !== undefined) {
+                for (const session of store.list()) {
+                    liveIds.add(session.id);
+                    for (const event of session.events) {
+                        if (beijingDayKey(new Date(event.time)) !== dayKey)
+                            continue;
+                        events.push(event);
+                        if (events.length >= maxEvents) {
+                            truncated = true;
+                            break;
+                        }
+                    }
+                    if (truncated)
+                        break;
+                }
+            }
+        }
+        const persistenceService = persistence?.();
+        if (!truncated && persistenceService !== undefined) {
+            const snapshots = await persistenceService.listSnapshots();
+            for (const { header, revision } of snapshots) {
+                if (liveIds.has(header.id))
+                    continue;
+                if (this.lastEventsScan?.get(header.id) === revision)
+                    continue;
+                try {
+                    const inspection = await persistenceService.inspect(header.id);
+                    for (const event of inspection.events) {
+                        if (beijingDayKey(new Date(event.time)) !== dayKey)
+                            continue;
+                        events.push(event);
+                        if (events.length >= maxEvents) {
+                            truncated = true;
+                            break;
+                        }
+                    }
+                }
+                catch (error) {
+                    // One unreadable session must not blank the whole-day aggregate.
+                    logger.warn(`llm-billing: skipping unreadable session ${header.id}: ${String(error)}`);
+                }
+                if (truncated)
+                    break;
+            }
+            // Only a complete pass may advance the revision watermark: a truncated
+            // pass left sessions unread, and recording them would skip their events
+            // on the next scan.
+            if (!truncated) {
+                this.lastEventsScan = new Map(snapshots.map(snapshot => [snapshot.header.id, snapshot.revision]));
+            }
+        }
+        if (truncated)
+            logger.warn(`llm-billing: today's events exceeded ${maxEvents}; result truncated`);
+        // The reference moment is derived from the day key (UTC midnight on that
+        // date is 08:00 Beijing the same day), so the pricing re-check cannot
+        // drift from the collection filter across a Beijing-day boundary.
+        return computeTodaySpend(events, billing, catalog, new Date(`${dayKey}T00:00:00Z`));
+    }
+}
+//# sourceMappingURL=today-spend.js.map

package/lib/types/types.d.ts

@@ -1,7 +1,7 @@
 /**
  * Client-safe balance and spend vocabulary shared by the `billing` Remote,
  * its generated artifacts, and the web UI.
- * @module @deepseek-ai/dsh-llm-billing/types
+ * @module @rayadesu/dsh-llm-billing/types
  */
 /** One currency line of the account balance returned by `GET /user/balance`. */
 export interface DeepSeekBalanceLine {
@@ -46,14 +46,14 @@ export interface DeepSeekSessionSpendModel {
     /** Billed cost of output tokens (reasoning included) in CNY. */
     outputCost: number;
 }
-/** The billed spend of one session, priced per event by its Beijing-time peak/off-peak hour. */
+/** The billed spend of one session, priced per event by its Beijing-time hour and weekday (peak hours apply Monday–Friday only; weekends are off-peak). */
 export interface DeepSeekSessionSpend {
     /** Total billed cost in CNY across every priced model. */
     total: number;
     /** One row per model that reported usage AND has a pricing row; empty when the session has no priced usage. */
     models: readonly DeepSeekSessionSpendModel[];
 }
-/** The billed spend of every session on one Beijing-time calendar day, priced per event by its peak/off-peak hour. */
+/** The billed spend of every session on one Beijing-time calendar day, priced per event by its Beijing-time hour and weekday (peak hours apply Monday–Friday only; weekends are off-peak). */
 export interface DeepSeekTodaySpend {
     /** Total billed cost in CNY across every priced model and every session. */
     total: number;

package/lib/types/types.js

@@ -1,7 +1,7 @@
 /**
  * Client-safe balance and spend vocabulary shared by the `billing` Remote,
  * its generated artifacts, and the web UI.
- * @module @deepseek-ai/dsh-llm-billing/types
+ * @module @rayadesu/dsh-llm-billing/types
  */
 export {};
 //# sourceMappingURL=types.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rayadesu/dsh-llm-billing",
   "description": "Standalone DeepSeek account-balance and session-spend provider exposed through the billing Remote",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "publishConfig": {
     "access": "public"
   },
@@ -47,16 +47,19 @@
     "lib/typert.remote-client.js",
     "lib/typert.remote-client.d.ts"
   ],
+  "scripts": {
+    "prepublishOnly": "node ../../scripts/verify-packages.mjs"
+  },
   "license": "MIT",
   "peerDependencies": {
-    "@deepseek-ai/dsh-credentials": "^0.1.0-rc.8",
-    "@deepseek-ai/dsh-launch-environment": "^0.1.0-rc.8",
-    "@deepseek-ai/dsh-invariants": "^0.1.0-rc.8",
-    "@deepseek-ai/dsh-llm": "^0.1.0-rc.8",
-    "@deepseek-ai/dsh-session": "^0.1.0-rc.8",
-    "@deepseek-ai/dsh-session-persistence": "^0.1.0-rc.8",
-    "@deepseek-ai/dsh-session-projection": "^0.1.0-rc.8",
-    "@deepseek-ai/dsh-typert-protocol": "^0.1.0-rc.8",
+    "@deepseek-ai/dsh-credentials": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-launch-environment": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-invariants": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-llm": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-session": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-session-persistence": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-session-projection": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-typert-protocol": "^0.1.1-rc.2",
     "@deepseek-ai/cordis": "^4.0.1"
   },
   "dependencies": {
@@ -64,14 +67,14 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@deepseek-ai/dsh-credentials": "^0.1.0-rc.8",
-    "@deepseek-ai/dsh-launch-environment": "^0.1.0-rc.8",
-    "@deepseek-ai/dsh-invariants": "^0.1.0-rc.8",
-    "@deepseek-ai/dsh-llm": "^0.1.0-rc.8",
-    "@deepseek-ai/dsh-session": "^0.1.0-rc.8",
-    "@deepseek-ai/dsh-session-persistence": "^0.1.0-rc.8",
-    "@deepseek-ai/dsh-session-projection": "^0.1.0-rc.8",
-    "@deepseek-ai/dsh-typert-protocol": "^0.1.0-rc.8",
+    "@deepseek-ai/dsh-credentials": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-launch-environment": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-invariants": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-llm": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-session": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-session-persistence": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-session-projection": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-typert-protocol": "^0.1.1-rc.2",
     "@deepseek-ai/cordis": "^4.0.1"
   }
 }