@goodandready/dsh-key-rotation 0.8.68 → 0.8.70

package/lib/pool.js

@@ -1,28 +1,15 @@
-export const MAX_SESSION_STICKY_ENTRIES = 500;
-
-export function setSessionSticky(pool, sessionId, candidate) {
-  if (!sessionId || !candidate || !pool?.state) return;
-  if (!(pool.state.sessionSticky instanceof Map)) {
-    pool.state.sessionSticky = new Map();
-  }
-  if (pool.state.sessionSticky.has(sessionId)) {
-    pool.state.sessionSticky.delete(sessionId);
-  } else if (pool.state.sessionSticky.size >= MAX_SESSION_STICKY_ENTRIES) {
-    const oldest = pool.state.sessionSticky.keys().next().value;
-    if (oldest !== undefined) pool.state.sessionSticky.delete(oldest);
-  }
-  pool.state.sessionSticky.set(sessionId, candidate);
-}
-
-export function getSessionSticky(pool, sessionId) {
-  if (!sessionId || !pool?.state?.sessionSticky) return null;
-  return pool.state.sessionSticky.get(sessionId) ?? null;
-}
-
-export function clearSessionSticky(pool, sessionId) {
-  if (!sessionId || !pool?.state?.sessionSticky) return;
-  pool.state.sessionSticky.delete(sessionId);
-}
+// lib/pool.js — pure pool arithmetic and selection logic for dsh-key-rotation.
+import {
+  MAX_SESSION_STICKY_ENTRIES, setSessionSticky, getSessionSticky, clearSessionSticky,
+  selectPool, sortAttemptList, expiringSoon, shouldNotifyDaily,
+  costForDay, costForWeek, budgetVerdict,
+} from './pool-selection.js';
+
+export {
+  MAX_SESSION_STICKY_ENTRIES, setSessionSticky, getSessionSticky, clearSessionSticky,
+  selectPool, sortAttemptList, expiringSoon, shouldNotifyDaily,
+  costForDay, costForWeek, budgetVerdict,
+};
 
 import { resetModelQuotaIfNeeded } from './model-quota.js';
 import { decryptSecret } from './crypto-storage.js';
@@ -239,6 +226,7 @@ export function sweepExpired(poolState, now = Date.now(), activeRefs = null, quo
   let cleared = 0;
   const activeSet = activeRefs ? new Set(activeRefs) : null;
   for (const st of poolState.values()) {
+    if (!st || !(st.failedUntil instanceof Map)) continue;
     // #338: decay penalty failCounts for stable keys in maintenance sweep
     decayPenalties({ state: st }, now);
     for (const [ref, until] of [...st.failedUntil.entries()]) {
@@ -288,19 +276,6 @@ export function parseRetryAfter(value) {
 }
 
 /** Pick a key pool for a (provider, model) pair. */
-export function selectPool(modelPoolByProvider, providerToPool, provider, model) {
-  const byModel = modelPoolByProvider && modelPoolByProvider.get(provider);
-  const base = providerToPool && providerToPool.get(provider);
-  if (!byModel || !model) return base ?? null;
-  if (byModel.has(model)) return byModel.get(model);
-  let best = null;
-  for (const key of byModel.keys()) {
-    if (model.startsWith(key) && key.length > (best ? best.length : 0)) best = key;
-  }
-  return (best ? byModel.get(best) : base) ?? null;
-}
-
-/** Parse an expiry value (timestamp ms or ISO date string) to epoch ms. */
 export function parseExpiry(v) {
   if (typeof v === 'number' && v > 0) return v;
   if (typeof v === 'string' && v.length > 0) { const ts = Date.parse(v); return Number.isNaN(ts) ? undefined : ts; }
@@ -434,61 +409,6 @@ export function isRateLimited(rate, threshold = 0.1) {
  * - 'least-loaded': keys with lowest active concurrency count first
  * - 'lowest-latency': keys with lowest p95 (or avg) latency first; unsampled keys neutral
  */
-export function sortAttemptList(refs, strategy = 'round-robin', deps = {}) {
-  if (!Array.isArray(refs) || refs.length <= 1) return (refs ?? []).slice();
-  const list = refs.slice();
-  if (strategy === 'sticky') {
-    const last = deps.sessionSticky ||
-      (deps.sessionId && (deps.pool?.state?.sessionSticky?.get?.(deps.sessionId) || deps.sessionStickyMap?.get?.(deps.sessionId))) ||
-      deps.lastUsed ||
-      (deps.pool && deps.pool.state && deps.pool.state.lastUsed);
-    if (last && list.includes(last)) {
-      const idx = list.indexOf(last);
-      if (idx > 0) {
-        list.splice(idx, 1);
-        list.unshift(last);
-      }
-    }
-    return list;
-  }
-  if (strategy === 'tier-priority') {
-    const tiers = deps.tiers || (deps.pool && deps.pool.tiers) || {};
-    return list.sort((a, b) => {
-      const ta = (tiers[a] && Number(tiers[a]) >= 1) ? Number(tiers[a]) : 1;
-      const tb = (tiers[b] && Number(tiers[b]) >= 1) ? Number(tiers[b]) : 1;
-      return ta - tb;
-    });
-  }
-  if (strategy === 'least-loaded' && deps.concurrencyTracker && typeof deps.concurrencyTracker.getActive === 'function') {
-    const weights = deps.weights || (deps.pool && deps.pool.weightsMap) || {};
-    return list.sort((a, b) => {
-      const ca = deps.concurrencyTracker.getActive(a) ?? 0;
-      const cb = deps.concurrencyTracker.getActive(b) ?? 0;
-      const wa = (weights[a] && Number(weights[a]) > 0) ? Number(weights[a]) : 1;
-      const wb = (weights[b] && Number(weights[b]) > 0) ? Number(weights[b]) : 1;
-      const scoreA = ca / wa;
-      const scoreB = cb / wb;
-      if (scoreA !== scoreB) return scoreA - scoreB;
-      return ca - cb;
-    });
-  }
-  if (strategy === 'lowest-latency' && deps.latencyHistogram && typeof deps.latencyHistogram.snapshot === 'function') {
-    return list.sort((a, b) => {
-      const sa = deps.latencyHistogram.snapshot(a);
-      const sb = deps.latencyHistogram.snapshot(b);
-      const la = (sa && Number.isFinite(sa.p95)) ? sa.p95 : ((sa && Number.isFinite(sa.avg)) ? sa.avg : 500);
-      const lb = (sb && Number.isFinite(sb.p95)) ? sb.p95 : ((sb && Number.isFinite(sb.avg)) ? sb.avg : 500);
-      return la - lb;
-    });
-  }
-  return list;
-}
-
-/**
- * Unified check whether an error or payload represents a switchable failure.
- * Prioritizes explicit HTTP status codes and gRPC codes before text matching.
- */
-/** Raw socket-level codes the taxonomy maps to TRANSPORT (see classifyFailure). */
 const SOCKET_TRANSPORT_CODES = new Set([
   'ECONNRESET', 'ECONNREFUSED', 'ETIMEDOUT', 'EPIPE', 'EAI_AGAIN', 'ENOTFOUND',
   'ECONNABORTED', 'UND_ERR_CONNECT_TIMEOUT', 'UND_ERR_SOCKET', 'UND_ERR_HEADERS_TIMEOUT',
@@ -565,58 +485,6 @@ export function formatExhaustionMessage(provider, pool, now = Date.now()) {
  * Keys of pool whose expiresAt falls within the next warnDays.
  * Returns [{ ref, expiresInDays, expiresAt }], soonest first.
  */
-export function expiringSoon(pool, warnDays = 7, now = Date.now()) {
-  if (!pool || !pool.expiresAt) return [];
-  const DAY_MS = 86400000;
-  const horizon = now + Math.max(1, warnDays) * DAY_MS;
-  return Object.entries(pool.expiresAt)
-    .filter(([, at]) => at > now && at <= horizon)
-    .map(([ref, at]) => ({ ref, expiresAt: at, expiresInDays: Math.max(0, Math.floor((at - now) / DAY_MS)) }))
-    .sort((a, b) => a.expiresAt - b.expiresAt);
-}
-
-/** Dedupe: true when a day-level notification for key is due. */
-export function shouldNotifyDaily(lastNotified, key, now = Date.now()) {
-  const DAY_MS = 86400000;
-  if (!lastNotified.has(key)) {
-    lastNotified.set(key, now);
-    return true;
-  }
-  const last = lastNotified.get(key);
-  if (now - last < DAY_MS) return false;
-  lastNotified.set(key, now);
-  return true;
-}
-
-/** Total spend of a pool on ISO day day (defaults to today) across costDays Map<ref, Map<day, cost>>. */
-export function costForDay(costDays, day) {
-  const d = day ?? new Date().toISOString().slice(0, 10);
-  let total = 0;
-  for (const perRef of (costDays?.values() ?? [])) {
-    total += perRef.get(d) ?? 0;
-  }
-  return total;
-}
-
-/** Total spend over the last 7 ISO days ending today. */
-export function costForWeek(costDays, now = Date.now()) {
-  let total = 0;
-  for (let i = 0; i < 7; i++) {
-    const d = new Date(now - i * 86400000).toISOString().slice(0, 10);
-    total += costForDay(costDays, d);
-  }
-  return total;
-}
-
-/** Budget verdict for a pool: { spend, budget, ratio, warn, exceeded }. */
-export function budgetVerdict(spend, budget) {
-  if (!budget || budget <= 0) return { spend, budget: 0, ratio: 0, warn: false, exceeded: false };
-  const ratio = spend / budget;
-  return { spend, budget, ratio, warn: ratio >= 0.8, exceeded: ratio >= 1 };
-}
-
-
-/** Safely reset a provider's circuit breaker to closed state. */
 export function resetCircuitForProvider(circuitBreaker, provider) {
   if (!circuitBreaker || !provider) return false;
   const ok = bestEffort('resetCircuitForProvider', () => {