@cortexkit/anthropic-auth-core 1.15.0 → 1.16.0

package/dist/sticky-routing.js

@@ -0,0 +1,450 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
+import { basename, dirname, join } from 'node:path';
+import { acquireRefreshFileLock, getKillswitchThresholdsForAccount, getQuotaCheckIntervalMs, getQuotaMinimumRemainingThresholds, getScopedQuotaWindowForModel, isKillswitchEnabled, } from "./accounts.js";
+import { isClaudeFableOrMythos5Model } from "./models.js";
+export const STICKY_ROUTING_MAIN_ACCOUNT_ID = 'main';
+export const STICKY_ROUTING_SHORT_RESET_GRACE_MS = 15 * 60_000;
+export const STICKY_ROUTING_ASSIGNMENT_TTL_MS = 7 * 24 * 60 * 60_000;
+const STICKY_ROUTING_TOUCH_INTERVAL_MS = 60 * 60_000;
+const STICKY_ROUTING_LOCK_TTL_MS = 10_000;
+const STICKY_ROUTING_LOCK_WAIT_MS = 5_000;
+const STICKY_ROUTING_LOCK_POLL_MS = 10;
+const STICKY_ROUTING_MAX_ASSIGNMENTS = 4_096;
+const MIN_WEIGHT = 0.000_001;
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function finiteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function normalizeAssignment(value) {
+    if (!isRecord(value))
+        return;
+    if (typeof value.accountId !== 'string' ||
+        !['fable', 'opus', 'general'].includes(String(value.family))) {
+        return;
+    }
+    const assignedAt = finiteNumber(value.assignedAt);
+    const lastSeenAt = finiteNumber(value.lastSeenAt);
+    const initialInputBytes = finiteNumber(value.initialInputBytes);
+    const quotaCheckedAt = finiteNumber(value.quotaCheckedAt);
+    if (assignedAt === undefined ||
+        lastSeenAt === undefined ||
+        initialInputBytes === undefined ||
+        quotaCheckedAt === undefined) {
+        return;
+    }
+    return {
+        accountId: value.accountId,
+        family: value.family,
+        assignedAt,
+        lastSeenAt,
+        initialInputBytes: Math.max(0, initialInputBytes),
+        quotaCheckedAt,
+    };
+}
+function normalizeState(value) {
+    if (!isRecord(value) || value.version !== 1 || !isRecord(value.assignments)) {
+        return;
+    }
+    const assignments = {};
+    for (const [key, assignment] of Object.entries(value.assignments)) {
+        const normalized = normalizeAssignment(assignment);
+        if (normalized)
+            assignments[key] = normalized;
+    }
+    return {
+        version: 1,
+        updatedAt: finiteNumber(value.updatedAt) ?? 0,
+        assignments,
+    };
+}
+function emptyState(now) {
+    return { version: 1, updatedAt: now, assignments: {} };
+}
+function sessionKey(sessionId) {
+    return createHash('sha256').update(sessionId).digest('hex');
+}
+export function stickyQuotaSnapshotIsFresh(quota, storage, now = Date.now(), modelId) {
+    const maxAge = getQuotaCheckIntervalMs(storage);
+    const standardFresh = ['five_hour', 'seven_day'].every((key) => {
+        const window = quota?.[key];
+        return Boolean(window && now - window.checkedAt < maxAge);
+    });
+    if (!standardFresh)
+        return false;
+    const scoped = getScopedQuotaWindowForModel(quota, modelId);
+    return !scoped || now - scoped.checkedAt < maxAge;
+}
+function snapshotCheckedAt(quota) {
+    return Math.max(quota.checkedAt ?? 0, quota.five_hour?.checkedAt ?? 0, quota.seven_day?.checkedAt ?? 0, ...(quota.scoped ?? []).map((window) => window.checkedAt ?? 0));
+}
+function remainingThreshold(storage, accountId, key) {
+    const quotaMinimum = getQuotaMinimumRemainingThresholds(storage);
+    const quotaThreshold = key === 'five_hour'
+        ? quotaMinimum.five_hour
+        : key === 'seven_day'
+            ? quotaMinimum.seven_day
+            : 0;
+    if (!isKillswitchEnabled(storage))
+        return quotaThreshold;
+    const killswitch = getKillswitchThresholdsForAccount(storage, accountId === STICKY_ROUTING_MAIN_ACCOUNT_ID ? undefined : accountId);
+    return Math.max(quotaThreshold, killswitch[key]);
+}
+function sustainableWindowWeight(remainingPercent, reservePercent, resetsAt, now) {
+    const spendable = Math.max(0, remainingPercent - reservePercent);
+    if (spendable <= 0)
+        return 0;
+    if (!resetsAt)
+        return spendable;
+    const resetAt = Date.parse(resetsAt);
+    if (!Number.isFinite(resetAt) || resetAt <= now)
+        return spendable;
+    const hoursUntilReset = Math.max((resetAt - now) / 3_600_000, 1 / 60);
+    return spendable / hoursUntilReset;
+}
+export function stickyRouteFamilyForModel(model) {
+    if (isClaudeFableOrMythos5Model(model))
+        return 'fable';
+    return typeof model === 'string' && model.toLowerCase().includes('opus')
+        ? 'opus'
+        : 'general';
+}
+export function stickyRouteCandidateWeight(input) {
+    const now = input.now ?? Date.now();
+    const { candidate, storage } = input;
+    if (!stickyQuotaSnapshotIsFresh(candidate.quota, storage, now, input.modelId)) {
+        return 0;
+    }
+    const weights = [];
+    for (const key of ['five_hour', 'seven_day']) {
+        const window = candidate.quota[key];
+        if (!window || !Number.isFinite(window.remainingPercent))
+            return 0;
+        weights.push(sustainableWindowWeight(window.remainingPercent, remainingThreshold(storage, candidate.accountId, key), window.resetsAt, now));
+    }
+    if (input.family === 'fable') {
+        const window = getScopedQuotaWindowForModel(candidate.quota, input.modelId);
+        if (window && Number.isFinite(window.remainingPercent)) {
+            weights.push(sustainableWindowWeight(window.remainingPercent, remainingThreshold(storage, candidate.accountId, 'scoped'), window.resetsAt, now));
+        }
+    }
+    return Math.min(...weights);
+}
+export function stickyRouteKnownFableExhausted(candidate, storage, now = Date.now()) {
+    const window = getScopedQuotaWindowForModel(candidate.quota, 'claude-fable-5');
+    return Boolean(window &&
+        stickyQuotaSnapshotIsFresh(candidate.quota, storage, now, 'claude-fable-5') &&
+        Number.isFinite(window.remainingPercent) &&
+        window.remainingPercent <= 0);
+}
+export function decideStickyQuotaFailure(input) {
+    const now = input.now ?? Date.now();
+    if (!input.quota)
+        return { action: 'retain', reason: 'unknown' };
+    const scoped = getScopedQuotaWindowForModel(input.quota, input.modelId);
+    if (scoped &&
+        Number.isFinite(scoped.remainingPercent) &&
+        scoped.remainingPercent <= 0) {
+        return { action: 'migrate', reason: 'model-scoped' };
+    }
+    const sevenDay = input.quota.seven_day;
+    if (sevenDay &&
+        Number.isFinite(sevenDay.remainingPercent) &&
+        sevenDay.remainingPercent <= 0) {
+        return { action: 'migrate', reason: 'seven-day' };
+    }
+    const fiveHour = input.quota.five_hour;
+    if (fiveHour &&
+        Number.isFinite(fiveHour.remainingPercent) &&
+        fiveHour.remainingPercent <= 0) {
+        const resetAt = fiveHour.resetsAt ? Date.parse(fiveHour.resetsAt) : NaN;
+        if (Number.isFinite(resetAt) &&
+            resetAt > now &&
+            resetAt - now <= STICKY_ROUTING_SHORT_RESET_GRACE_MS) {
+            return {
+                action: 'hold',
+                reason: 'five-hour-short-reset',
+                retryAfterSeconds: Math.max(1, Math.ceil((resetAt - now) / 1000)),
+            };
+        }
+        return { action: 'migrate', reason: 'five-hour' };
+    }
+    return { action: 'retain', reason: 'not-exhausted' };
+}
+export function getStickyRoutingStatePath(accountStoragePath) {
+    const name = basename(accountStoragePath);
+    const stem = name.endsWith('.json') ? name.slice(0, -5) : name;
+    return join(dirname(accountStoragePath), `${stem}-routing-state.json`);
+}
+export function stickyRetryAfterWithJitter(sessionId, retryAfterSeconds) {
+    const hash = createHash('sha256').update(sessionId).digest().readUInt32BE(0);
+    return Math.max(1, Math.ceil(retryAfterSeconds)) + (hash % 21);
+}
+export class StickySessionRouter {
+    options;
+    loaded = false;
+    state;
+    stateMtimeNs;
+    touchChain = Promise.resolve();
+    constructor(options) {
+        this.options = options;
+        this.state = emptyState(this.now());
+    }
+    now() {
+        return this.options.now?.() ?? Date.now();
+    }
+    async readState() {
+        try {
+            const raw = await readFile(this.options.path, 'utf8');
+            const normalized = normalizeState(JSON.parse(raw));
+            if (!normalized) {
+                throw new Error(`Invalid sticky routing state at ${this.options.path}`);
+            }
+            return normalized;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return emptyState(this.now());
+            }
+            throw error;
+        }
+    }
+    async readStateMtimeNs() {
+        try {
+            return (await stat(this.options.path, { bigint: true })).mtimeNs;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return 0n;
+            throw error;
+        }
+    }
+    async refreshStateIfChanged() {
+        for (let attempt = 0; attempt < 3; attempt++) {
+            const before = await this.readStateMtimeNs();
+            if (this.loaded && before === this.stateMtimeNs)
+                return;
+            const state = await this.readState();
+            const after = await this.readStateMtimeNs();
+            if (before !== after)
+                continue;
+            this.state = state;
+            this.stateMtimeNs = after;
+            this.loaded = true;
+            return;
+        }
+        this.state = await this.readState();
+        this.stateMtimeNs = await this.readStateMtimeNs();
+        this.loaded = true;
+    }
+    async acquireLock() {
+        await mkdir(dirname(this.options.path), { recursive: true, mode: 0o700 });
+        const deadline = this.now() + STICKY_ROUTING_LOCK_WAIT_MS;
+        while (true) {
+            const lock = await acquireRefreshFileLock({
+                name: 'write',
+                path: this.options.path,
+                ttlMs: STICKY_ROUTING_LOCK_TTL_MS,
+                renew: true,
+            });
+            if (lock)
+                return lock;
+            if (this.now() >= deadline) {
+                throw new Error('Timed out acquiring sticky routing state lock');
+            }
+            await new Promise((resolve) => setTimeout(resolve, STICKY_ROUTING_LOCK_POLL_MS));
+        }
+    }
+    assignmentIsActive(assignment) {
+        return (assignment.lastSeenAt >=
+            this.now() -
+                (this.options.assignmentTtlMs ?? STICKY_ROUTING_ASSIGNMENT_TTL_MS));
+    }
+    prune(state) {
+        const cutoff = this.now() -
+            (this.options.assignmentTtlMs ?? STICKY_ROUTING_ASSIGNMENT_TTL_MS);
+        for (const [key, assignment] of Object.entries(state.assignments)) {
+            if (assignment.lastSeenAt < cutoff)
+                delete state.assignments[key];
+        }
+        const entries = Object.entries(state.assignments);
+        if (entries.length <= STICKY_ROUTING_MAX_ASSIGNMENTS)
+            return;
+        entries
+            .sort((left, right) => right[1].lastSeenAt - left[1].lastSeenAt)
+            .slice(STICKY_ROUTING_MAX_ASSIGNMENTS)
+            .forEach(([key]) => {
+            delete state.assignments[key];
+        });
+    }
+    async writeState(state) {
+        this.prune(state);
+        state.updatedAt = this.now();
+        const tempPath = `${this.options.path}.${randomUUID()}.tmp`;
+        try {
+            await writeFile(tempPath, `${JSON.stringify(state)}\n`, { mode: 0o600 });
+            await rename(tempPath, this.options.path);
+        }
+        finally {
+            await rm(tempPath, { force: true }).catch(() => { });
+        }
+        this.state = state;
+        this.stateMtimeNs = await this.readStateMtimeNs();
+        this.loaded = true;
+    }
+    scheduleTouch(key) {
+        this.touchChain = this.touchChain
+            .catch(() => { })
+            .then(async () => {
+            const lock = await this.acquireLock();
+            try {
+                const state = await this.readState();
+                const assignment = state.assignments[key];
+                if (!assignment)
+                    return;
+                assignment.lastSeenAt = this.now();
+                await this.writeState(state);
+            }
+            finally {
+                await lock.release();
+            }
+        })
+            .catch(() => { });
+    }
+    selectCandidate(input) {
+        let candidates = [...input.candidates];
+        if (input.family === 'opus') {
+            const depleted = candidates.filter((candidate) => stickyRouteKnownFableExhausted(candidate, input.storage, this.now()));
+            if (depleted.length > 0)
+                candidates = depleted;
+        }
+        const weighted = candidates.flatMap((candidate) => {
+            const weight = stickyRouteCandidateWeight({
+                candidate,
+                family: input.family,
+                modelId: input.modelId,
+                storage: input.storage,
+                now: this.now(),
+            });
+            return weight > 0 ? [{ candidate, weight }] : [];
+        });
+        if (weighted.length === 0)
+            return undefined;
+        const pendingBytes = new Map();
+        for (const assignment of Object.values(input.state.assignments)) {
+            const candidate = weighted.find((entry) => entry.candidate.accountId === assignment.accountId)?.candidate;
+            if (!candidate)
+                continue;
+            if (assignment.quotaCheckedAt !== snapshotCheckedAt(candidate.quota))
+                continue;
+            pendingBytes.set(assignment.accountId, (pendingBytes.get(assignment.accountId) ?? 0) +
+                assignment.initialInputBytes);
+        }
+        return weighted
+            .map(({ candidate, weight }) => ({
+            candidate,
+            score: ((pendingBytes.get(candidate.accountId) ?? 0) + input.inputBytes) /
+                Math.max(weight, MIN_WEIGHT),
+        }))
+            .sort((left, right) => left.score - right.score ||
+            left.candidate.order - right.candidate.order ||
+            left.candidate.accountId.localeCompare(right.candidate.accountId))[0]?.candidate;
+    }
+    async resolve(input) {
+        if (!input.sessionId)
+            return null;
+        await this.refreshStateIfChanged();
+        const key = sessionKey(input.sessionId);
+        const cached = this.state.assignments[key];
+        if (cached &&
+            this.assignmentIsActive(cached) &&
+            input.retainAccountIds.has(cached.accountId) &&
+            !input.excludeAccountIds?.has(cached.accountId)) {
+            if (this.now() - cached.lastSeenAt >= STICKY_ROUTING_TOUCH_INTERVAL_MS) {
+                cached.lastSeenAt = this.now();
+                this.scheduleTouch(key);
+            }
+            return {
+                accountId: cached.accountId,
+                assignment: { ...cached },
+                created: false,
+                migrated: false,
+            };
+        }
+        const lock = await this.acquireLock();
+        try {
+            const state = await this.readState();
+            this.prune(state);
+            const current = state.assignments[key];
+            if (current &&
+                input.retainAccountIds.has(current.accountId) &&
+                !input.excludeAccountIds?.has(current.accountId)) {
+                current.lastSeenAt = this.now();
+                await this.writeState(state);
+                return {
+                    accountId: current.accountId,
+                    assignment: { ...current },
+                    created: false,
+                    migrated: false,
+                };
+            }
+            const candidates = input.candidates.filter((candidate) => !input.excludeAccountIds?.has(candidate.accountId));
+            const preferred = input.preferredAccountId
+                ? candidates.find((candidate) => candidate.accountId === input.preferredAccountId &&
+                    stickyRouteCandidateWeight({
+                        candidate,
+                        family: input.family,
+                        modelId: input.modelId,
+                        storage: input.storage,
+                        now: this.now(),
+                    }) > 0)
+                : undefined;
+            const selected = preferred ?? this.selectCandidate({ ...input, candidates, state });
+            if (!selected) {
+                if (current) {
+                    delete state.assignments[key];
+                    await this.writeState(state);
+                }
+                return null;
+            }
+            const now = this.now();
+            const assignment = {
+                accountId: selected.accountId,
+                family: input.family,
+                assignedAt: now,
+                lastSeenAt: now,
+                initialInputBytes: Math.max(1, input.inputBytes),
+                quotaCheckedAt: snapshotCheckedAt(selected.quota),
+            };
+            state.assignments[key] = assignment;
+            await this.writeState(state);
+            return {
+                accountId: selected.accountId,
+                assignment: { ...assignment },
+                created: !current,
+                migrated: Boolean(current && current.accountId !== selected.accountId),
+            };
+        }
+        finally {
+            await lock.release();
+        }
+    }
+    async clear(sessionId) {
+        if (!sessionId)
+            return;
+        const key = sessionKey(sessionId);
+        const lock = await this.acquireLock();
+        try {
+            const state = await this.readState();
+            if (!(key in state.assignments))
+                return;
+            delete state.assignments[key];
+            await this.writeState(state);
+        }
+        finally {
+            await lock.release();
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/anthropic-auth-core",
-  "version": "1.15.0",
+  "version": "1.16.0",
   "type": "module",
   "repository": {
     "type": "git",