@modelprofile.com/authswitch 6.4.0 → 7.0.0

package/dist_ts/classes.authorityusage.d.ts

@@ -0,0 +1,160 @@
+import * as plugins from './plugins.js';
+import type { IClaudeLogin, IClaudeStatusRead } from './classes.claudestatus.js';
+type TRateLimits = plugins.flexAccounts.ISmartAiProviderAccountRateLimits;
+export type TAuthSwitchUsageProblem = 'none' | 'unsupported' | 'access_unavailable' | 'provider_unavailable' | 'provider_rejected' | 'profile_unavailable' | 'usage_unavailable' | 'context_changed' | 'expired';
+export interface IAuthSwitchNativeUsageSource {
+    homeId: string;
+    credentialDigest: string;
+    configDigest: string;
+    accessTokenDigest: string;
+}
+/** A credential-free, exact view of the account and login used for one usage read. */
+export interface IAuthSwitchUsageContext {
+    epoch: string;
+    accountId: string;
+    loginId: string;
+    subjectId: string;
+    workspaceId: string;
+    providerId: string;
+    purpose: string;
+    owner: string;
+    grantState: string;
+    removed: boolean;
+    authorizationGeneration: number;
+    grantGeneration: number;
+    nativeSource: IAuthSwitchNativeUsageSource | null;
+}
+/** A bounded, credential-free projection; it is independent of the legacy harness API. */
+export interface IAuthSwitchClaudeStatus {
+    plan: {
+        name: string;
+        source: 'live' | 'stored';
+    } | null;
+    windows: {
+        label: string;
+        scope: 'account' | 'feature';
+        durationSeconds: number;
+        usedPercent: number;
+        resetAt: string | null;
+        severity?: 'normal' | 'warning' | 'critical';
+        headline?: true;
+    }[] | null;
+    facts: {
+        section: string | null;
+        label: string;
+        value: string;
+        summaryKey?: 'subscription' | 'billing' | 'usageWindows' | 'resets' | 'resetDetails';
+    }[];
+    problems: string[];
+    rateLimit: {
+        retryAt: string | null;
+    } | null;
+}
+export type TAuthSwitchUsageReading = {
+    kind: 'openai';
+    rateLimits: TRateLimits;
+} | {
+    kind: 'anthropic';
+    status: IAuthSwitchClaudeStatus;
+};
+export interface IAuthSwitchUsageAccess {
+    accessToken: string;
+    accountId: string;
+    isFedrampAccount: boolean;
+    expiresAt: string;
+    grantGeneration: number;
+}
+/** Persist through SmartData in the authority integration. No credential belongs in this record. */
+export interface IAuthSwitchStoredUsage {
+    context: IAuthSwitchUsageContext;
+    updateId: string;
+    reading: TAuthSwitchUsageReading | null;
+    observedAt: string | null;
+    currentUntil: string | null;
+    staleUntil: string | null;
+    lastAttemptAt: string;
+    nextAttemptAt: string;
+    failures: number;
+    problem: Exclude<TAuthSwitchUsageProblem, 'context_changed' | 'expired'>;
+}
+export interface IAuthSwitchUsageSnapshot {
+    accountId: string;
+    loginId: string;
+    state: 'current' | 'partial' | 'stale' | 'unavailable';
+    reading: TAuthSwitchUsageReading | null;
+    observedAt: string | null;
+    currentUntil: string | null;
+    staleUntil: string | null;
+    lastAttemptAt: string | null;
+    nextAttemptAt: string | null;
+    problem: TAuthSwitchUsageProblem;
+}
+export interface IAuthSwitchUsageStore {
+    /** Read only the exact login's record. The helper discards a mismatched context. */
+    read(accountId: string, loginId: string): Promise<IAuthSwitchStoredUsage | null>;
+    /**
+     * In one SmartData transaction, re-read epoch/account/login and compare every semantic
+     * context field, compare the previous usage update ID, write next, and append a revisioned
+     * account event. The account row revision may increase in that transaction; it is not
+     * part of the usage validity key and must not invalidate the reading just published.
+     * A null previousUpdateId also permits replacing a record for a different context;
+     * it must reject a concurrently written record for this same context.
+     * Return false on either conflict; do not publish an old provider callback.
+     */
+    publishIfCurrent(context: IAuthSwitchUsageContext, previousUpdateId: string | null, next: IAuthSwitchStoredUsage): Promise<boolean>;
+}
+export interface IAuthSwitchAuthorityUsageOptions {
+    /** Re-read from the owning SmartData authority. Return null for an absent login. */
+    readContext(accountId: string, loginId: string): Promise<IAuthSwitchUsageContext | null>;
+    /** Broker-owned access resolution; rejected generation may perform at most one durable refresh. */
+    resolveAccess(context: IAuthSwitchUsageContext, rejectedGrantGeneration: number | undefined, minValidityMs: number): Promise<IAuthSwitchUsageAccess>;
+    resolveClaudeLogin?(context: IAuthSwitchUsageContext, rejectedGrantGeneration: number | undefined, minValidityMs: number): Promise<{
+        login: IClaudeLogin;
+        grantGeneration: number;
+        expiresAt: string | null;
+    }>;
+    claudeStatus?: Pick<{
+        readDetailed(login: IClaudeLogin): Promise<IClaudeStatusRead>;
+    }, 'readDetailed'>;
+    /** The callback holds the qualified vendor lease through the whole read and publication. */
+    withNativeSource?(context: IAuthSwitchUsageContext, action: (source: {
+        context: IAuthSwitchUsageContext;
+        login: IClaudeLogin;
+        readContext(): Promise<IAuthSwitchUsageContext | null>;
+    }) => Promise<IAuthSwitchUsageSnapshot>): Promise<IAuthSwitchUsageSnapshot>;
+    store: IAuthSwitchUsageStore;
+    provider: Pick<plugins.flexAccounts.ISmartAiProviderAdapter, 'getAccountRateLimits'>;
+    now?: () => number;
+    currentMaxAgeMs?: number;
+    maxStaleAgeMs?: number;
+    minAttemptIntervalMs?: number;
+    retryBaseMs?: number;
+    retryMaxMs?: number;
+    providerTimeoutMs?: number;
+    minAccessValidityMs?: number;
+}
+/** On-demand daemon cache coordinator. The injected store is the only publication authority. */
+export declare class AuthSwitchAuthorityUsage {
+    private readonly options;
+    private readonly now;
+    private readonly policy;
+    private readonly pending;
+    private readonly admitted;
+    private closed;
+    private closing?;
+    constructor(options: IAuthSwitchAuthorityUsageOptions);
+    private unavailable;
+    private snapshot;
+    private currentContext;
+    get(accountId: string, loginId: string, force?: boolean): Promise<IAuthSwitchUsageSnapshot>;
+    private read;
+    private readWithContext;
+    /** Coalesce the entire read/decision/fetch lifecycle, including the first stored read. */
+    private readForContext;
+    private refresh;
+    private validAccess;
+    private query;
+    /** Wait for admitted reads before the daemon disposes the shared provider or database. */
+    close(): Promise<void>;
+}
+export {};

package/dist_ts/classes.authorityusage.js

@@ -0,0 +1,429 @@
+import * as plugins from './plugins.js';
+const defaults = {
+    currentMaxAgeMs: 60_000,
+    maxStaleAgeMs: 300_000,
+    minAttemptIntervalMs: 15_000,
+    retryBaseMs: 30_000,
+    retryMaxMs: 300_000,
+    providerTimeoutMs: 15_000,
+    minAccessValidityMs: 60_000,
+};
+const sameContext = (left, right) => left.epoch === right.epoch && left.accountId === right.accountId && left.loginId === right.loginId
+    && left.subjectId === right.subjectId && left.workspaceId === right.workspaceId
+    && left.providerId === right.providerId
+    && left.purpose === right.purpose && left.owner === right.owner && left.grantState === right.grantState
+    && left.removed === right.removed && left.authorizationGeneration === right.authorizationGeneration
+    && left.grantGeneration === right.grantGeneration
+    && (left.nativeSource === null ? right.nativeSource === null
+        : right.nativeSource !== null && left.nativeSource.homeId === right.nativeSource.homeId
+            && left.nativeSource.credentialDigest === right.nativeSource.credentialDigest
+            && left.nativeSource.configDigest === right.nativeSource.configDigest
+            && left.nativeSource.accessTokenDigest === right.nativeSource.accessTokenDigest);
+const sameGrantAuthority = (left, right) => left.epoch === right.epoch && left.accountId === right.accountId && left.loginId === right.loginId
+    && left.subjectId === right.subjectId && left.workspaceId === right.workspaceId
+    && left.providerId === right.providerId
+    && left.purpose === right.purpose && left.owner === right.owner
+    && left.authorizationGeneration === right.authorizationGeneration && !right.removed
+    && (left.nativeSource === null ? right.nativeSource === null : sameContext(left, right));
+const usable = (context) => !context.removed && ((context.providerId === 'openai' && context.purpose === 'openai_managed'
+    && context.owner === 'daemon' && context.nativeSource === null
+    && (context.grantState === 'ready' || context.grantState === 'retry_wait'))
+    || (context.providerId === 'anthropic' && context.purpose === 'claude_host_native'
+        && ((context.owner === 'daemon' && context.nativeSource === null
+            && (context.grantState === 'ready' || context.grantState === 'retry_wait'))
+            || (context.owner === 'claude_native' && context.nativeSource !== null
+                && context.grantState === 'native'))));
+const timestamp = (millis) => new Date(millis).toISOString();
+const future = (value, now) => value !== null && Date.parse(value) > now;
+const safeText = (value) => {
+    const text = value.replace(/[\u0000-\u001f\u007f-\u009f]/g, '');
+    if (Array.from(text).length > 500)
+        throw new Error('Claude status text exceeds the authority projection bound.');
+    return text;
+};
+const publicClaudeStatus = (source) => {
+    if ((source.summary?.usageWindows?.length ?? 0) > 128 || source.facts.length > 128
+        || source.problems.length > 32)
+        throw new Error('Claude status exceeds the authority projection bound.');
+    return {
+        plan: source.summary?.subscription
+            ? { name: safeText(source.summary.subscription.plan), source: source.summary.subscription.source } : null,
+        windows: source.summary?.usageWindows?.map(window => ({
+            label: safeText(window.label), scope: window.scope ?? 'account',
+            durationSeconds: window.durationSeconds, usedPercent: window.usedPercent, resetAt: window.resetAt,
+            ...(window.severity ? { severity: window.severity } : {}),
+            ...(window.headline ? { headline: true } : {}),
+        })) ?? null,
+        facts: source.facts.map(fact => ({
+            section: fact.section ? safeText(fact.section) : null,
+            label: safeText(fact.label), value: safeText(fact.value),
+            ...(fact.summaryKey ? { summaryKey: fact.summaryKey } : {}),
+        })),
+        problems: source.problems.map(safeText),
+        rateLimit: source.rateLimit ? { retryAt: source.rateLimit.retryAt } : null,
+    };
+};
+/** Allowlist the provider projection before it enters a management DTO or stored usage record. */
+const publicRateLimits = (source) => {
+    const window = (value) => ({
+        usedPercent: value.usedPercent, limitWindowSeconds: value.limitWindowSeconds,
+        resetAfterSeconds: value.resetAfterSeconds, resetsAt: value.resetsAt,
+    });
+    const detail = (value) => ({
+        allowed: value.allowed, limitReached: value.limitReached,
+        ...(value.primaryWindow ? { primaryWindow: window(value.primaryWindow) } : {}),
+        ...(value.secondaryWindow ? { secondaryWindow: window(value.secondaryWindow) } : {}),
+    });
+    return {
+        providerId: 'openai', plan: source.plan, observedAt: source.observedAt,
+        ...(source.rateLimit ? { rateLimit: detail(source.rateLimit) } : {}),
+        additionalRateLimits: source.additionalRateLimits.map(item => ({
+            limitName: item.limitName, meteredFeature: item.meteredFeature,
+            ...(item.rateLimit ? { rateLimit: detail(item.rateLimit) } : {}),
+        })),
+        ...(source.rateLimitReachedType === undefined ? {} : { rateLimitReachedType: source.rateLimitReachedType }),
+        ...(source.rateLimitResetCreditsAvailableCount === undefined ? {}
+            : { rateLimitResetCreditsAvailableCount: source.rateLimitResetCreditsAvailableCount }),
+    };
+};
+/** On-demand daemon cache coordinator. The injected store is the only publication authority. */
+export class AuthSwitchAuthorityUsage {
+    options;
+    now;
+    policy;
+    pending = new Map();
+    admitted = new Set();
+    closed = false;
+    closing;
+    constructor(options) {
+        this.options = options;
+        this.now = options.now ?? Date.now;
+        this.policy = {
+            currentMaxAgeMs: options.currentMaxAgeMs ?? defaults.currentMaxAgeMs,
+            maxStaleAgeMs: options.maxStaleAgeMs ?? defaults.maxStaleAgeMs,
+            minAttemptIntervalMs: options.minAttemptIntervalMs ?? defaults.minAttemptIntervalMs,
+            retryBaseMs: options.retryBaseMs ?? defaults.retryBaseMs,
+            retryMaxMs: options.retryMaxMs ?? defaults.retryMaxMs,
+            providerTimeoutMs: options.providerTimeoutMs ?? defaults.providerTimeoutMs,
+            minAccessValidityMs: options.minAccessValidityMs ?? defaults.minAccessValidityMs,
+        };
+        if (Object.values(this.policy).some(value => !Number.isSafeInteger(value) || value < 1 || value > 3_600_000)
+            || this.policy.maxStaleAgeMs <= this.policy.currentMaxAgeMs
+            || this.policy.retryMaxMs < this.policy.retryBaseMs) {
+            throw new Error('Invalid authority usage freshness policy.');
+        }
+    }
+    unavailable(accountId, loginId, problem) {
+        return { accountId, loginId, state: 'unavailable', reading: null, observedAt: null,
+            currentUntil: null, staleUntil: null, lastAttemptAt: null, nextAttemptAt: null, problem };
+    }
+    snapshot(context, record, now = this.now()) {
+        if (!record || !sameContext(context, record.context)) {
+            return this.unavailable(context.accountId, context.loginId, 'expired');
+        }
+        const state = record.reading && future(record.currentUntil, now)
+            ? record.problem === 'none' ? 'current'
+                : record.reading.kind === 'anthropic' && ['profile_unavailable', 'usage_unavailable'].includes(record.problem)
+                    ? 'partial' : 'stale'
+            : record.reading && future(record.staleUntil, now) ? 'stale' : 'unavailable';
+        return {
+            accountId: context.accountId, loginId: context.loginId, state,
+            reading: state === 'unavailable' ? null : record.reading,
+            observedAt: state === 'unavailable' ? null : record.observedAt,
+            currentUntil: record.currentUntil, staleUntil: record.staleUntil,
+            lastAttemptAt: record.lastAttemptAt, nextAttemptAt: record.nextAttemptAt,
+            problem: state === 'unavailable' && record.reading && !future(record.staleUntil, now)
+                ? 'expired' : record.problem,
+        };
+    }
+    async currentContext(accountId, loginId) {
+        try {
+            return await this.options.readContext(accountId, loginId);
+        }
+        catch {
+            return null;
+        }
+    }
+    get(accountId, loginId, force = false) {
+        if (this.closed)
+            return Promise.reject(new Error('Authority usage helper is closed.'));
+        const request = this.read(accountId, loginId, force);
+        this.admitted.add(request);
+        void request.finally(() => this.admitted.delete(request)).catch(() => undefined);
+        return request;
+    }
+    async read(accountId, loginId, force) {
+        if (!/^[a-f0-9]{64}$/.test(accountId) || !/^[a-f0-9]{64}$/.test(loginId)) {
+            throw new Error('Invalid authority usage identity.');
+        }
+        const context = await this.currentContext(accountId, loginId);
+        if (!context)
+            return this.unavailable(accountId, loginId, 'access_unavailable');
+        if (context.accountId !== accountId || context.loginId !== loginId) {
+            return this.unavailable(accountId, loginId, 'context_changed');
+        }
+        if (context.providerId === 'anthropic' && context.purpose === 'claude_host_native'
+            && context.owner === 'claude_native' && context.grantState === 'native') {
+            if (!this.options.withNativeSource)
+                return this.unavailable(accountId, loginId, 'access_unavailable');
+            try {
+                return await this.options.withNativeSource(context, async (source) => {
+                    const readCurrent = async () => {
+                        try {
+                            return await source.readContext();
+                        }
+                        catch {
+                            return null;
+                        }
+                    };
+                    return this.readWithContext(source.context, force, readCurrent, source.login);
+                });
+            }
+            catch {
+                return this.unavailable(accountId, loginId, 'access_unavailable');
+            }
+        }
+        return this.readWithContext(context, force, () => this.currentContext(accountId, loginId), null);
+    }
+    readWithContext(context, force, readCurrent, nativeLogin) {
+        if (!usable(context))
+            return Promise.resolve(this.unavailable(context.accountId, context.loginId, context.removed || ['handoff_pending', 'handoff_quarantined', 'legacy_native_pending'].includes(context.grantState)
+                ? 'access_unavailable' : 'unsupported'));
+        const key = JSON.stringify([context.epoch, context.accountId, context.loginId,
+            context.subjectId, context.workspaceId,
+            context.authorizationGeneration, context.grantGeneration, context.owner, context.grantState,
+            context.nativeSource]);
+        const existing = this.pending.get(key);
+        if (existing)
+            return existing;
+        const task = this.readForContext(context, force, readCurrent, nativeLogin).finally(() => {
+            if (this.pending.get(key) === task)
+                this.pending.delete(key);
+        });
+        this.pending.set(key, task);
+        return task;
+    }
+    /** Coalesce the entire read/decision/fetch lifecycle, including the first stored read. */
+    async readForContext(context, force, readCurrent, nativeLogin) {
+        let stored;
+        try {
+            stored = await this.options.store.read(context.accountId, context.loginId);
+        }
+        catch {
+            return this.unavailable(context.accountId, context.loginId, 'access_unavailable');
+        }
+        const record = stored && sameContext(context, stored.context) ? stored : null;
+        const verified = await readCurrent();
+        if (!verified || !sameContext(context, verified)) {
+            return this.unavailable(context.accountId, context.loginId, 'context_changed');
+        }
+        const now = this.now();
+        const cached = this.snapshot(context, record, now);
+        if (record && future(record.nextAttemptAt, now))
+            return cached;
+        if (cached.state === 'current' && !force)
+            return cached;
+        return this.refresh(context, record, readCurrent, nativeLogin);
+    }
+    async refresh(initial, initialRecord, readCurrent, nativeLogin) {
+        let context = initial;
+        let previous = initialRecord;
+        let reading = null;
+        let problem = 'none';
+        try {
+            if (context.providerId === 'openai') {
+                let access = await this.options.resolveAccess(context, undefined, this.policy.minAccessValidityMs);
+                const resolved = await readCurrent();
+                if (!resolved || !sameGrantAuthority(context, resolved) || !usable(resolved)
+                    || resolved.grantGeneration !== access.grantGeneration) {
+                    return this.unavailable(context.accountId, context.loginId, 'context_changed');
+                }
+                context = resolved;
+                if (!this.validAccess(context, access))
+                    throw new Error('Access grant is unavailable.');
+                if (!sameContext(initial, context)) {
+                    const stored = await this.options.store.read(context.accountId, context.loginId);
+                    previous = stored && sameContext(context, stored.context) ? stored : null;
+                }
+                let response;
+                try {
+                    response = await this.query(access);
+                }
+                catch {
+                    problem = 'provider_unavailable';
+                    response = { success: false, errorCode: 'ACCOUNT_RATE_LIMITS_FAILED' };
+                }
+                if (!response.success && response.errorCode === 'CREDENTIAL_REFRESH_REQUIRED') {
+                    const beforeRotation = await readCurrent();
+                    if (!beforeRotation || !sameContext(context, beforeRotation)) {
+                        return this.unavailable(context.accountId, context.loginId, 'context_changed');
+                    }
+                    access = await this.options.resolveAccess(context, access.grantGeneration, this.policy.minAccessValidityMs);
+                    const rotated = await readCurrent();
+                    if (!rotated || !sameGrantAuthority(context, rotated) || !usable(rotated)
+                        || rotated.grantGeneration !== access.grantGeneration
+                        || rotated.grantGeneration <= context.grantGeneration) {
+                        return this.unavailable(context.accountId, context.loginId, 'context_changed');
+                    }
+                    context = rotated;
+                    if (!this.validAccess(context, access))
+                        throw new Error('Access grant is unavailable.');
+                    const stored = await this.options.store.read(context.accountId, context.loginId);
+                    previous = stored && sameContext(context, stored.context) ? stored : null;
+                    try {
+                        response = await this.query(access);
+                    }
+                    catch {
+                        problem = 'provider_unavailable';
+                        response = { success: false, errorCode: 'ACCOUNT_RATE_LIMITS_FAILED' };
+                    }
+                }
+                if (response.success)
+                    reading = { kind: 'openai', rateLimits: publicRateLimits(response.rateLimits) };
+                else if (problem === 'none')
+                    problem = response.errorCode === 'CREDENTIAL_REFRESH_REQUIRED'
+                        ? 'provider_rejected' : 'provider_unavailable';
+            }
+            else if (context.providerId === 'anthropic' && this.options.claudeStatus) {
+                let login = nativeLogin;
+                let grantGeneration = context.grantGeneration;
+                if (context.owner === 'daemon') {
+                    if (!this.options.resolveClaudeLogin)
+                        throw new Error('Claude status access is unavailable.');
+                    const access = await this.options.resolveClaudeLogin(context, undefined, this.policy.minAccessValidityMs);
+                    login = access.login;
+                    grantGeneration = access.grantGeneration;
+                    if (login.scopes.includes('user:profile')
+                        && !future(access.expiresAt, this.now() + this.policy.minAccessValidityMs)) {
+                        throw new Error('Claude status access is not fresh enough.');
+                    }
+                }
+                const resolved = await readCurrent();
+                if (!resolved || !sameGrantAuthority(context, resolved) || !usable(resolved)
+                    || resolved.grantGeneration !== grantGeneration || !login) {
+                    return this.unavailable(context.accountId, context.loginId, 'context_changed');
+                }
+                context = resolved;
+                if (!sameContext(initial, context)) {
+                    const stored = await this.options.store.read(context.accountId, context.loginId);
+                    previous = stored && sameContext(context, stored.context) ? stored : null;
+                }
+                if (!login.scopes.includes('user:profile')) {
+                    problem = 'unsupported';
+                }
+                else {
+                    let result = await this.options.claudeStatus.readDetailed(login);
+                    if (result.credentialRejected && context.owner === 'daemon') {
+                        const beforeRotation = await readCurrent();
+                        if (!beforeRotation || !sameContext(context, beforeRotation)) {
+                            return this.unavailable(context.accountId, context.loginId, 'context_changed');
+                        }
+                        const rotated = await this.options.resolveClaudeLogin(context, grantGeneration, this.policy.minAccessValidityMs);
+                        const updated = await readCurrent();
+                        if (!updated || !sameGrantAuthority(context, updated) || !usable(updated)
+                            || updated.grantGeneration !== rotated.grantGeneration
+                            || updated.grantGeneration <= grantGeneration
+                            || (rotated.login.scopes.includes('user:profile')
+                                && !future(rotated.expiresAt, this.now() + this.policy.minAccessValidityMs))) {
+                            return this.unavailable(context.accountId, context.loginId, 'context_changed');
+                        }
+                        context = updated;
+                        login = rotated.login;
+                        const stored = await this.options.store.read(context.accountId, context.loginId);
+                        previous = stored && sameContext(context, stored.context) ? stored : null;
+                        if (login.scopes.includes('user:profile')) {
+                            result = await this.options.claudeStatus.readDetailed(login);
+                        }
+                        else {
+                            problem = 'unsupported';
+                        }
+                    }
+                    if (problem !== 'unsupported' && result.profile === 'mismatch') {
+                        return this.unavailable(context.accountId, context.loginId, 'context_changed');
+                    }
+                    else if (problem !== 'unsupported' && result.credentialRejected)
+                        problem = 'provider_rejected';
+                    else if (problem !== 'unsupported' && context.owner === 'claude_native' && result.profile !== 'verified') {
+                        problem = 'profile_unavailable';
+                    }
+                    else if (problem !== 'unsupported') {
+                        try {
+                            reading = { kind: 'anthropic', status: publicClaudeStatus(result.status) };
+                            problem = result.profile !== 'verified' ? 'profile_unavailable'
+                                : result.usage !== 'available' ? 'usage_unavailable' : 'none';
+                        }
+                        catch {
+                            problem = 'unsupported';
+                        }
+                    }
+                }
+            }
+            else {
+                problem = 'unsupported';
+            }
+        }
+        catch {
+            problem = 'access_unavailable';
+        }
+        const latest = await readCurrent();
+        if (!latest || !sameContext(context, latest) || !usable(latest)) {
+            return this.unavailable(context.accountId, context.loginId, 'context_changed');
+        }
+        const now = this.now();
+        const failures = reading && problem === 'none' ? 0 : Math.min((previous?.failures ?? 0) + 1, 16);
+        const retryMs = Math.min(this.policy.retryBaseMs * 2 ** Math.min(failures - 1, 10), this.policy.retryMaxMs);
+        const retained = !reading && previous?.reading && future(previous.staleUntil, now) ? previous : null;
+        const next = {
+            context, updateId: plugins.crypto.randomUUID(),
+            reading: reading ?? retained?.reading ?? null,
+            observedAt: reading ? timestamp(now) : retained?.observedAt ?? null,
+            currentUntil: reading ? timestamp(now + this.policy.currentMaxAgeMs) : retained?.currentUntil ?? null,
+            staleUntil: reading ? timestamp(now + this.policy.maxStaleAgeMs) : retained?.staleUntil ?? null,
+            lastAttemptAt: timestamp(now),
+            nextAttemptAt: timestamp(now + (reading && problem === 'none' ? this.policy.minAttemptIntervalMs : retryMs)),
+            failures, problem,
+        };
+        try {
+            if (!await this.options.store.publishIfCurrent(context, previous?.updateId ?? null, next)) {
+                const current = await readCurrent();
+                if (!current || !sameContext(context, current)) {
+                    return this.unavailable(context.accountId, context.loginId, 'context_changed');
+                }
+                const stored = await this.options.store.read(context.accountId, context.loginId);
+                const confirmed = await readCurrent();
+                if (!confirmed || !sameContext(context, confirmed)) {
+                    return this.unavailable(context.accountId, context.loginId, 'context_changed');
+                }
+                return this.snapshot(context, stored);
+            }
+        }
+        catch {
+            return this.unavailable(context.accountId, context.loginId, 'access_unavailable');
+        }
+        const confirmed = await readCurrent();
+        if (!confirmed || !sameContext(context, confirmed)) {
+            return this.unavailable(context.accountId, context.loginId, 'context_changed');
+        }
+        return this.snapshot(context, next);
+    }
+    validAccess(context, access) {
+        return Boolean(access.accessToken) && access.accountId === context.workspaceId
+            && access.grantGeneration === context.grantGeneration
+            && future(access.expiresAt, this.now() + this.policy.minAccessValidityMs);
+    }
+    query(access) {
+        const credential = { kind: 'chatgptAccess', providerId: 'openai',
+            accessToken: access.accessToken, accountId: access.accountId,
+            isFedrampAccount: access.isFedrampAccount };
+        return this.options.provider.getAccountRateLimits(credential, { timeoutMs: this.policy.providerTimeoutMs });
+    }
+    /** Wait for admitted reads before the daemon disposes the shared provider or database. */
+    close() {
+        if (this.closing)
+            return this.closing;
+        this.closed = true;
+        this.closing = Promise.allSettled([...this.admitted]).then(() => undefined);
+        return this.closing;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.authorityusage.js","sourceRoot":"","sources":["../ts/classes.authorityusage.ts"],"names":[],"mappings":"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"}