sidekick-shared 0.21.0 → 0.21.2

package/dist/zaiQuotaWatcher.js

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZaiQuotaWatcher = void 0;
+/**
+ * Deprecated event-driven watcher that derives a z.ai coding-plan
+ * `QuotaState` from observed OpenCode assistant turns.
+ *
+ * This watcher is retained for compatibility. Product code now uses
+ * `zaiQuotaApi.ts` to call z.ai's authoritative quota endpoint. The legacy
+ * watcher maintains rolling 5-hour / 7-day windows in memory and recomputes a
+ * derived `QuotaState` whenever a new turn arrives. The consumer is
+ * responsible for feeding it z.ai-routed assistant turns (and any trapped
+ * error events) — typically by subscribing to `SessionMonitor.onSessionEvent`
+ * and filtering on `providerID ∈ {zai, zai-coding-plan}`.
+ *
+ * Optionally writes snapshots + history samples for cross-session cache
+ * and trend visualisation, mirroring `CodexQuotaWatcher`.
+ */
+const quotaHistory_1 = require("./quotaHistory");
+const quotaSnapshots_1 = require("./quotaSnapshots");
+const zaiQuota_1 = require("./zaiQuota");
+const DEFAULT_ACCOUNT_ID = 'default';
+const DEFAULT_RECOMPUTE_DEBOUNCE_MS = 1_000;
+const DEFAULT_PRUNE_INTERVAL_MS = 60_000;
+const SEVEN_DAY_MS = 7 * 86_400_000;
+function enrichZaiState(state) {
+    return {
+        ...state,
+        runtimeProvider: 'zai',
+        providerId: 'zai',
+    };
+}
+/**
+ * Watches z.ai-routed OpenCode activity and emits derived `QuotaState`.
+ *
+ * The watcher is event-driven (not a poller): call `ingestAssistantTurn`
+ * for every observed z.ai assistant turn, and `ingestError` whenever a
+ * z.ai business error is observed. The watcher debounces recompute and
+ * emits via `onUpdate` / `onQuotaUpdate`.
+ */
+class ZaiQuotaWatcher {
+    tier;
+    resolveTier;
+    readSnapshot;
+    writeSnapshot;
+    appendHistorySample;
+    workspaceId;
+    accountId;
+    recomputeDebounceMs;
+    pruneIntervalMs;
+    now;
+    listeners = [];
+    /** In-memory rolling 7-day buffer of observed turns. */
+    turns = [];
+    /** Most recent authoritative 5h reset (parsed from a z.ai error event). */
+    authoritativeFiveHourResetAt;
+    /** Most recent authoritative weekly reset (parsed from a z.ai error event). */
+    authoritativeWeeklyResetAt;
+    /** Most recent trapped error (so consumers can show "rate-limited until X"). */
+    lastError = null;
+    lastEmissionKey = null;
+    pendingRecomputeTimer;
+    pruneTimer;
+    running = false;
+    constructor(options = {}) {
+        this.tier = options.tier ?? 'auto';
+        this.resolveTier = options.resolveTier ?? zaiQuota_1.resolveZaiTier;
+        this.readSnapshot = options.readSnapshot ?? quotaSnapshots_1.readQuotaSnapshot;
+        this.writeSnapshot = options.writeSnapshot ?? quotaSnapshots_1.writeQuotaSnapshot;
+        this.appendHistorySample = options.appendHistorySample ?? quotaHistory_1.appendQuotaHistorySample;
+        this.workspaceId = options.workspaceId;
+        this.accountId = options.accountId ?? DEFAULT_ACCOUNT_ID;
+        this.recomputeDebounceMs = options.recomputeDebounceMs ?? DEFAULT_RECOMPUTE_DEBOUNCE_MS;
+        this.pruneIntervalMs = options.pruneIntervalMs ?? DEFAULT_PRUNE_INTERVAL_MS;
+        this.now = options.now ?? Date.now;
+    }
+    start() {
+        if (this.running)
+            return;
+        this.running = true;
+        // Emit cached state immediately so consumers don't show "unavailable"
+        // during the gap before the first z.ai turn arrives.
+        this.emitCachedOrUnavailable();
+        this.pruneTimer = setInterval(() => this.pruneOldTurns(), this.pruneIntervalMs);
+    }
+    stop() {
+        if (!this.running)
+            return;
+        this.running = false;
+        if (this.pendingRecomputeTimer) {
+            clearTimeout(this.pendingRecomputeTimer);
+            this.pendingRecomputeTimer = undefined;
+        }
+        if (this.pruneTimer) {
+            clearInterval(this.pruneTimer);
+            this.pruneTimer = undefined;
+        }
+    }
+    dispose() {
+        this.stop();
+        this.listeners.splice(0, this.listeners.length);
+    }
+    onUpdate(cb) {
+        this.listeners.push(cb);
+        return {
+            dispose: () => {
+                const index = this.listeners.indexOf(cb);
+                if (index >= 0)
+                    this.listeners.splice(index, 1);
+            },
+        };
+    }
+    onQuotaUpdate(cb) {
+        return this.onUpdate(cb);
+    }
+    /** Feed an observed z.ai assistant turn. Schedules a debounced recompute. */
+    ingestAssistantTurn(turn) {
+        this.turns.push(turn);
+        this.scheduleRecompute();
+    }
+    /**
+     * Feed multiple turns at once (used for cold-start seeding from the DB).
+     * Schedules a single debounced recompute.
+     */
+    ingestAssistantTurns(turns) {
+        for (const turn of turns)
+            this.turns.push(turn);
+        this.scheduleRecompute();
+    }
+    /** Feed a z.ai error event. Triggers an immediate recompute + emit. */
+    ingestError(error) {
+        const parsed = (0, zaiQuota_1.parseZaiQuotaError)(error);
+        if (!parsed)
+            return false;
+        this.lastError = parsed;
+        if (parsed.resetsAt) {
+            // The first observed error after the user crosses a threshold tells
+            // us the authoritative window boundary. Apply to whichever window
+            // the kind maps to.
+            if (parsed.kind === 'exhausted') {
+                this.authoritativeFiveHourResetAt = parsed.resetsAt;
+                // 1310 is "weekly/monthly exhausted" — also pin the weekly window.
+                if (String(parsed.code) === '1310') {
+                    this.authoritativeWeeklyResetAt = parsed.resetsAt;
+                }
+            }
+        }
+        this.scheduleRecompute();
+        return true;
+    }
+    /** Force a recompute+emit now (skipping the debounce). Used by tests. */
+    refresh() {
+        this.recomputeAndEmit();
+    }
+    /** Current in-memory turn count (testing/diagnostics). */
+    get bufferedTurnCount() {
+        return this.turns.length;
+    }
+    // ── internals ──
+    scheduleRecompute() {
+        if (!this.running)
+            return;
+        if (this.pendingRecomputeTimer)
+            clearTimeout(this.pendingRecomputeTimer);
+        this.pendingRecomputeTimer = setTimeout(() => {
+            this.pendingRecomputeTimer = undefined;
+            this.recomputeAndEmit();
+        }, this.recomputeDebounceMs);
+    }
+    recomputeAndEmit() {
+        const nowMs = this.now();
+        const accumulated = (0, zaiQuota_1.accumulateZaiUsage)(this.turns, nowMs);
+        const tier = this.resolveTier(this.tier, accumulated);
+        const state = accumulated.fiveHourTurns > 0 || accumulated.weeklyTurns > 0
+            ? (0, zaiQuota_1.inferZaiQuotaState)(accumulated, tier, {
+                capturedAt: new Date(nowMs).toISOString(),
+                stale: false,
+                authoritativeFiveHourResetAt: this.authoritativeFiveHourResetAt,
+                authoritativeWeeklyResetAt: this.authoritativeWeeklyResetAt,
+            })
+            : (0, zaiQuota_1.makeUnavailableZaiQuotaState)(undefined, tier, new Date(nowMs).toISOString());
+        // If we recently saw an error, override availability so the UI shows it.
+        if (this.lastError) {
+            state.error = this.lastError.message;
+            state.failureKind = this.lastError.kind === 'expired' ? 'auth' : 'rate_limit';
+            state.rateLimitReachedType = this.lastError.kind;
+        }
+        this.writeSnapshot('zai', this.accountId, state);
+        this.maybeAppendHistory(state);
+        this.emitState(enrichZaiState(state));
+    }
+    maybeAppendHistory(state) {
+        if (!this.workspaceId)
+            return;
+        const sample = {
+            timestamp: state.capturedAt ?? new Date(this.now()).toISOString(),
+            runtimeProvider: 'zai',
+            providerId: this.accountId,
+            workspaceId: this.workspaceId,
+            fiveHour: { utilization: state.fiveHour.utilization, resetsAt: state.fiveHour.resetsAt },
+            sevenDay: { utilization: state.sevenDay.utilization, resetsAt: state.sevenDay.resetsAt },
+            available: state.available,
+            error: state.error,
+            source: 'session',
+            stale: state.stale,
+        };
+        try {
+            const result = this.appendHistorySample(sample);
+            if (result && typeof result.catch === 'function') {
+                result.catch(() => {
+                    // History append must never break the live emission path.
+                });
+            }
+        }
+        catch {
+            // Synchronous errors swallowed for the same reason.
+        }
+    }
+    emitCachedOrUnavailable() {
+        const cached = this.readSnapshot('zai', this.accountId);
+        if (cached) {
+            this.emitState(enrichZaiState({
+                ...cached,
+                providerId: 'zai',
+                source: 'cache',
+                stale: true,
+                fiveHourLabel: cached.fiveHourLabel ?? '5-Hour',
+                sevenDayLabel: cached.sevenDayLabel ?? 'Weekly',
+            }));
+            return;
+        }
+        // Initial state with no observations yet.
+        const tier = this.tier === 'auto' ? 'lite' : this.tier;
+        this.emitState(enrichZaiState((0, zaiQuota_1.makeUnavailableZaiQuotaState)(undefined, tier)));
+    }
+    emitState(state) {
+        const nextKey = JSON.stringify(state);
+        if (this.lastEmissionKey === nextKey)
+            return;
+        this.lastEmissionKey = nextKey;
+        for (const listener of this.listeners) {
+            try {
+                listener(state);
+            }
+            catch {
+                // Listener failures must not stop the watcher.
+            }
+        }
+    }
+    pruneOldTurns() {
+        const cutoff = this.now() - SEVEN_DAY_MS;
+        if (this.turns.length === 0)
+            return;
+        const next = this.turns.filter(turn => turn.timestampMs >= cutoff);
+        if (next.length !== this.turns.length) {
+            this.turns = next;
+        }
+    }
+}
+exports.ZaiQuotaWatcher = ZaiQuotaWatcher;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sidekick-shared",
-  "version": "0.21.0",
+  "version": "0.21.2",
   "description": "Shared data access layer for Sidekick — readers, types, providers, credentials, quota",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",