@goodandready/dsh-key-rotation 0.7.30 → 0.7.32

package/lib/bucket.js

@@ -1,52 +1,129 @@
-// lib/bucket.js - per-key RPM token bucket (#192).
-// ponytail: RPM only - true token counts are not visible before the stream
-// starts; wire TPM in when pi-ai surfaces usage on the resolve path.
-const WINDOW_MS = 60000;
-
-/** Sliding-window check: true if `ref` is under `limit` requests/min. */
-export function bucketAllow(windows, ref, limit, now = Date.now()) {
-  if (!limit || limit <= 0) return true;
-  const cut = now - WINDOW_MS;
-  const hits = (windows.get(ref) ?? []).filter((t) => t > cut);
-  if (hits.length >= limit) {
-    windows.set(ref, hits);
-    return false;
-  }
-  hits.push(now);
-  windows.set(ref, hits);
-  return true;
-}
-
-/** Record a hit without checking (use after a successful resolve). */
-export function bucketHit(windows, ref, now = Date.now()) {
-  const cut = now - WINDOW_MS;
-  const hits = (windows.get(ref) ?? []).filter((t) => t > cut);
-  hits.push(now);
-  windows.set(ref, hits);
-}
-
-/** ms until `ref` may retry again (0 = now). */
-export function bucketRetryMs(windows, ref, limit, now = Date.now()) {
-  if (!limit || limit <= 0) return 0;
-  const hits = (windows.get(ref) ?? []).filter((t) => t > now - WINDOW_MS);
-  if (hits.length < limit) return 0;
-  return Math.max(0, hits[0] + WINDOW_MS - now);
-}
-
-/** Drop state for refs that no longer exist. */
-export function bucketSweep(windows, liveRefs) {
-  for (const ref of [...windows.keys()]) {
-    if (!liveRefs.has(ref)) windows.delete(ref);
-  }
-}
-
-/** #210: snapshot for /status - used/remaining/resetMs for one ref. */
-export function bucketInfo(windows, ref, limit, now = Date.now()) {
-  if (!limit || limit <= 0) return null;
-  const hits = (windows?.get(ref) ?? []).filter((t) => t > now - WINDOW_MS);
-  return {
-    used: hits.length,
-    remaining: Math.max(0, limit - hits.length),
-    resetMs: hits.length ? Math.max(0, hits[0] + WINDOW_MS - now) : 0,
-  };
-}
+// lib/bucket.js - per-key RPM token bucket (#192) + O(1) accumulator and adaptive tuning.
+const WINDOW_MS = 60000;
+
+/**
+ * O(1) Mathematical Token Bucket Accumulator.
+ * tokens = min(capacity, tokens + (now - lastRefill) * refillRate)
+ */
+export class TokenBucketAccumulator {
+  constructor(capacity, windowMs = WINDOW_MS, now = Date.now()) {
+    this.capacity = Math.max(1, capacity);
+    this.tokens = this.capacity;
+    this.windowMs = windowMs;
+    this.refillRate = this.capacity / this.windowMs; // tokens per ms
+    this.lastRefill = now;
+  }
+
+  refill(now = Date.now()) {
+    const elapsed = Math.max(0, now - this.lastRefill);
+    if (elapsed > 0) {
+      this.tokens = Math.min(this.capacity, this.tokens + elapsed * this.refillRate);
+      this.lastRefill = now;
+    }
+  }
+
+  allow(cost = 1, now = Date.now()) {
+    this.refill(now);
+    if (this.tokens >= cost) {
+      this.tokens -= cost;
+      return true;
+    }
+    return false;
+  }
+
+  retryMs(cost = 1, now = Date.now()) {
+    this.refill(now);
+    if (this.tokens >= cost) return 0;
+    const needed = cost - this.tokens;
+    return Math.ceil(needed / this.refillRate);
+  }
+
+  updateCapacity(newCapacity, now = Date.now()) {
+    this.refill(now);
+    const prevCap = this.capacity;
+    this.capacity = Math.max(1, newCapacity);
+    this.refillRate = this.capacity / this.windowMs;
+    // Scale current tokens proportionally or clamp
+    this.tokens = Math.min(this.capacity, Math.max(0, this.tokens + (this.capacity - prevCap)));
+  }
+
+  info(now = Date.now()) {
+    this.refill(now);
+    const used = Math.max(0, Math.round(this.capacity - this.tokens));
+    const remaining = Math.max(0, Math.floor(this.tokens));
+    return {
+      used,
+      remaining,
+      resetMs: this.retryMs(1, now),
+      capacity: this.capacity,
+    };
+  }
+}
+
+/** Sliding-window check: true if `ref` is under `limit` requests/min. */
+export function bucketAllow(windows, ref, limit, now = Date.now()) {
+  if (!limit || limit <= 0) return true;
+  const cut = now - WINDOW_MS;
+  const hits = (windows.get(ref) ?? []).filter((t) => t > cut);
+  if (hits.length >= limit) {
+    windows.set(ref, hits);
+    return false;
+  }
+  hits.push(now);
+  windows.set(ref, hits);
+  return true;
+}
+
+/** Record a hit without checking (use after a successful resolve). */
+export function bucketHit(windows, ref, now = Date.now()) {
+  const cut = now - WINDOW_MS;
+  const hits = (windows.get(ref) ?? []).filter((t) => t > cut);
+  hits.push(now);
+  windows.set(ref, hits);
+}
+
+/** ms until `ref` may retry again (0 = now). */
+export function bucketRetryMs(windows, ref, limit, now = Date.now()) {
+  if (!limit || limit <= 0) return 0;
+  const hits = (windows.get(ref) ?? []).filter((t) => t > now - WINDOW_MS);
+  if (hits.length < limit) return 0;
+  return Math.max(0, hits[0] + WINDOW_MS - now);
+}
+
+/** Drop state for refs that no longer exist. */
+export function bucketSweep(windows, liveRefs) {
+  for (const ref of [...windows.keys()]) {
+    if (!liveRefs.has(ref)) windows.delete(ref);
+  }
+}
+
+/** Snapshot for /status - used/remaining/resetMs for one ref. */
+export function bucketInfo(windows, ref, limit, now = Date.now()) {
+  if (!limit || limit <= 0) return null;
+  const hits = (windows?.get(ref) ?? []).filter((t) => t > now - WINDOW_MS);
+  return {
+    used: hits.length,
+    remaining: Math.max(0, limit - hits.length),
+    resetMs: hits.length ? Math.max(0, hits[0] + WINDOW_MS - now) : 0,
+  };
+}
+
+/**
+ * Adaptive limit computation from HTTP headers with manual limit precedence.
+ * If manualLimit is given (> 0), it acts as the upper ceiling.
+ * If adaptive is enabled and upstream reports a lower limit/remaining, adapt downwards.
+ */
+export function computeEffectiveLimit(headerRateLimit, manualLimit, adaptiveEnabled = true) {
+  const manual = (Number.isFinite(manualLimit) && manualLimit > 0) ? manualLimit : null;
+  if (!adaptiveEnabled || !headerRateLimit) {
+    return manual;
+  }
+  const headerLimit = headerRateLimit.limit;
+  if (Number.isFinite(headerLimit) && headerLimit > 0) {
+    if (manual) {
+      return Math.min(manual, headerLimit); // manual acts as upper ceiling
+    }
+    return headerLimit;
+  }
+  return manual;
+}

package/lib/canary.js

@@ -1,56 +1,63 @@
-// canary.js — canary probing before releasing a key from cooldown (issue #196).
-
-export const CANARY_PROBE_TIMEOUT_MS = 5000;
-export const CANARY_DEFAULT_INTERVAL_MS = 30 * 1000;
-
-export class CanaryProber {
-  constructor(opts) {
-    opts = opts || {};
-    if (!opts.sandboxRunner) throw new Error('canary: sandboxRunner required');
-    this._runner = opts.sandboxRunner;
-    this._intervalMs = opts.intervalMs || CANARY_DEFAULT_INTERVAL_MS;
-    this._results = new Map();
-    this._inProgress = new Set();
-  }
-
-  get intervalMs() { return this._intervalMs; }
-
-  async probe(ref, key) {
-    if (!ref || this._inProgress.has(ref)) return null;
-    this._inProgress.add(ref);
-    try {
-      const result = await this._runner.probeModels(ref, key);
-      this._results.set(ref, Object.assign({}, result, { at: Date.now() }));
-      return result;
-    } catch (e) {
-      return { ok: false, code: 'error', at: Date.now() };
-    } finally {
-      this._inProgress.delete(ref);
-    }
-  }
-
-  lastResult(ref) {
-    return this._results.get(ref) || null;
-  }
-
-  isHealthy(ref) {
-    const r = this._results.get(ref);
-    return Boolean(r && r.ok);
-  }
-
-  clear(ref) {
-    if (ref) {
-      this._results.delete(ref);
-      this._inProgress.delete(ref);
-    } else {
-      this._results.clear();
-      this._inProgress.clear();
-    }
-  }
-
-  snapshot() {
-    const out = {};
-    for (const [k, v] of this._results) out[k] = v;
-    return out;
-  }
-}
+// canary.js — canary probing before releasing a key from cooldown (issue #196, #7).
+
+export const CANARY_PROBE_TIMEOUT_MS = 5000;
+export const CANARY_DEFAULT_INTERVAL_MS = 30 * 1000;
+
+export class CanaryProber {
+  constructor(opts) {
+    opts = opts || {};
+    if (!opts.sandboxRunner) throw new Error('canary: sandboxRunner required');
+    this._runner = opts.sandboxRunner;
+    this._intervalMs = opts.intervalMs || CANARY_DEFAULT_INTERVAL_MS;
+    this._probeTargetModel = Boolean(opts.probeTargetModel);
+    this._results = new Map();
+    this._inProgress = new Set();
+  }
+
+  get intervalMs() { return this._intervalMs; }
+  get probeTargetModel() { return this._probeTargetModel; }
+
+  async probe(ref, key, targetModel = null) {
+    if (!ref || this._inProgress.has(ref)) return null;
+    this._inProgress.add(ref);
+    try {
+      let result;
+      if (this._probeTargetModel && targetModel && typeof this._runner.probeChatCompletion === 'function') {
+        result = await this._runner.probeChatCompletion(ref, key, targetModel);
+      } else {
+        result = await this._runner.probeModels(ref, key);
+      }
+      this._results.set(ref, Object.assign({}, result, { at: Date.now() }));
+      return result;
+    } catch (e) {
+      return { ok: false, code: 'error', at: Date.now() };
+    } finally {
+      this._inProgress.delete(ref);
+    }
+  }
+
+  lastResult(ref) {
+    return this._results.get(ref) || null;
+  }
+
+  isHealthy(ref) {
+    const r = this._results.get(ref);
+    return Boolean(r && r.ok);
+  }
+
+  clear(ref) {
+    if (ref) {
+      this._results.delete(ref);
+      this._inProgress.delete(ref);
+    } else {
+      this._results.clear();
+      this._inProgress.clear();
+    }
+  }
+
+  snapshot() {
+    const out = {};
+    for (const [k, v] of this._results) out[k] = v;
+    return out;
+  }
+}

package/lib/client-helpers.js

@@ -1,21 +1,21 @@
-export function formatAgo(t, at) {
-  if (!at) return '';
-  const sec = Math.max(0, Math.round((Date.now() - at) / 1000));
-  if (sec < 60) return t('justNow');
-  if (sec < 3600) return t('minutesAgo').replace('{n}', String(Math.round(sec / 60)));
-  return t('hoursAgo').replace('{n}', String(Math.round(sec / 3600)));
-}
-
-export function nextKeyRef(providerId, existingKeys, allRefs) {
-  const fromExisting = (existingKeys || []).find((k) => typeof k === 'string' && k.length > 0);
-  const base = fromExisting
-    ? fromExisting.replace(/_\d+$/, '')
-    : String(providerId || 'provider').toUpperCase().replace(/[^A-Z0-9]+/g, '_').replace(/^_+|_+$/g, '') + '_API_KEY';
-  const taken = new Set(allRefs);
-  if (!taken.has(base)) return base;
-  for (let n = 2; n < 1000; n++) {
-    const candidate = base + '_' + n;
-    if (!taken.has(candidate)) return candidate;
-  }
-  return base + '_' + Date.now();
-}
+export function formatAgo(t, at) {
+  if (!at) return '';
+  const sec = Math.max(0, Math.round((Date.now() - at) / 1000));
+  if (sec < 60) return t('justNow');
+  if (sec < 3600) return t('minutesAgo').replace('{n}', String(Math.round(sec / 60)));
+  return t('hoursAgo').replace('{n}', String(Math.round(sec / 3600)));
+}
+
+export function nextKeyRef(providerId, existingKeys, allRefs) {
+  const fromExisting = (existingKeys || []).find((k) => typeof k === 'string' && k.length > 0);
+  const base = fromExisting
+    ? fromExisting.replace(/_\d+$/, '')
+    : String(providerId || 'provider').toUpperCase().replace(/[^A-Z0-9]+/g, '_').replace(/^_+|_+$/g, '') + '_API_KEY';
+  const taken = new Set(allRefs);
+  if (!taken.has(base)) return base;
+  for (let n = 2; n < 1000; n++) {
+    const candidate = base + '_' + n;
+    if (!taken.has(candidate)) return candidate;
+  }
+  return base + '_' + Date.now();
+}