@modelprofile.com/authswitch 6.5.0 → 8.0.0

package/dist_ts/classes.authoritypreuse.d.ts

@@ -0,0 +1,47 @@
+import * as plugins from './plugins.js';
+import type { IAuthSwitchPreuseOperation } from './authority-contract.js';
+import { AuthSwitchAuthorityBroker } from './classes.authoritybroker.js';
+import { AuthSwitchAuthorityDatabase } from './classes.authoritydatabase.js';
+import { type ICodexPreuseLifecycle } from './classes.codexpreuse.js';
+import type { IHarnessPreuseOptions, IHarnessPreuseResult } from './interfaces.harness.js';
+export interface IAuthSwitchAuthorityPreuseExecutor {
+    runAccess(credential: plugins.flexAccounts.IOpenAiChatGptAccessCredential, options: IHarnessPreuseOptions, lifecycle: ICodexPreuseLifecycle): Promise<IHarnessPreuseResult>;
+}
+export interface IAuthSwitchAuthorityPreuseOptions {
+    executor?: IAuthSwitchAuthorityPreuseExecutor;
+    now?: () => number;
+    minAccessValidityMs?: number;
+}
+export interface IAuthSwitchAuthorityPreuseRequest {
+    operationId: string;
+    accountId: string;
+    loginId: string;
+    purpose: 'openai_managed';
+    prompt: string;
+    model?: string;
+}
+export type TAuthSwitchAuthorityPreuseFreshAdmission = () => 'admitted' | 'account_busy';
+/** Durable, at-most-once owner of one quota-consuming inference for one exact login. */
+export declare class AuthSwitchAuthorityPreuse {
+    private readonly database;
+    private readonly broker;
+    private readonly executor;
+    private readonly now;
+    private readonly minAccessValidityMs;
+    private readonly starts;
+    private readonly running;
+    private closed;
+    constructor(database: AuthSwitchAuthorityDatabase, broker: AuthSwitchAuthorityBroker, options?: IAuthSwitchAuthorityPreuseOptions);
+    /** Terminalize every abandoned record before management admission opens. */
+    start(): Promise<void>;
+    begin(input: IAuthSwitchAuthorityPreuseRequest, admitFresh: TAuthSwitchAuthorityPreuseFreshAdmission): Promise<IAuthSwitchPreuseOperation>;
+    private admit;
+    private perform;
+    private fail;
+    private readStored;
+    get(operationId: string): Promise<IAuthSwitchPreuseOperation>;
+    cancel(operationId: string): Promise<IAuthSwitchPreuseOperation>;
+    wait(operationId: string): Promise<void>;
+    hasActive(operationId: string): boolean;
+    close(): Promise<void>;
+}

package/dist_ts/classes.authoritypreuse.js

@@ -0,0 +1,277 @@
+import * as plugins from './plugins.js';
+import { AuthSwitchAuthorityBroker } from './classes.authoritybroker.js';
+import { AuthSwitchAuthorityDatabase } from './classes.authoritydatabase.js';
+import { CodexPreuse } from './classes.codexpreuse.js';
+import { validatePreuseOptions } from './preuse.js';
+const uuid = (value) => typeof value === 'string' && /^[a-f0-9-]{36}$/.test(value);
+const hash = (value) => typeof value === 'string' && /^[a-f0-9]{64}$/.test(value);
+const publicOperation = (operation) => ({
+    id: operation.id, accountId: operation.accountId, loginId: operation.grantId,
+    purpose: operation.purpose, requestedModel: operation.requestedModel, model: operation.model,
+    state: operation.state, result: operation.result, problem: operation.problem,
+    createdAt: operation.createdAt, updatedAt: operation.updatedAt,
+    finishedAt: operation.finishedAt, revision: operation.revision,
+});
+/** Durable, at-most-once owner of one quota-consuming inference for one exact login. */
+export class AuthSwitchAuthorityPreuse {
+    database;
+    broker;
+    executor;
+    now;
+    minAccessValidityMs;
+    starts = new Map();
+    running = new Map();
+    closed = false;
+    constructor(database, broker, options = {}) {
+        this.database = database;
+        this.broker = broker;
+        this.executor = options.executor ?? new CodexPreuse();
+        this.now = options.now ?? Date.now;
+        this.minAccessValidityMs = options.minAccessValidityMs ?? 300_000;
+    }
+    /** Terminalize every abandoned record before management admission opens. */
+    async start() {
+        for (const state of ['preparing', 'request_may_have_started']) {
+            let after = null;
+            while (true) {
+                const page = await this.database.preuseOperationsByState(state, after);
+                if (!page.length)
+                    break;
+                for (const operation of page) {
+                    const updateId = plugins.crypto.randomUUID();
+                    const now = new Date(this.now()).toISOString();
+                    await this.database.changePreuseOperation(updateId, operation.id, current => {
+                        if (current.state !== state)
+                            throw new Error('Preuse recovery changed concurrently.');
+                        return { ...current, state: state === 'preparing' ? 'not_sent' : 'outcome_unknown',
+                            problem: state === 'preparing' ? 'interrupted' : 'request_uncertain',
+                            updatedAt: now, finishedAt: now, revision: current.revision + 1, updateId };
+                    });
+                }
+                after = page.at(-1).id;
+            }
+        }
+    }
+    begin(input, admitFresh) {
+        if (this.closed)
+            return Promise.reject(new Error('Authswitch preuse is closing.'));
+        if (!uuid(input.operationId) || !hash(input.accountId) || !hash(input.loginId)
+            || input.purpose !== 'openai_managed') {
+            return Promise.reject(new Error('Invalid preuse target.'));
+        }
+        validatePreuseOptions({ prompt: input.prompt, model: input.model });
+        const requestedModel = input.model ?? null;
+        const requestHash = plugins.crypto.createHash('sha256').update(JSON.stringify([
+            'authswitch-preuse-v1', input.accountId, input.loginId, input.purpose, input.prompt, requestedModel,
+        ])).digest('hex');
+        const active = this.running.get(input.operationId);
+        if (active) {
+            if (active.requestHash !== requestHash)
+                return Promise.reject(new Error('Preuse operation ID belongs to a different request.'));
+            return this.get(input.operationId);
+        }
+        const starting = this.starts.get(input.operationId);
+        if (starting) {
+            if (starting.requestHash !== requestHash)
+                return Promise.reject(new Error('Preuse operation ID belongs to a different request.'));
+            return starting.promise;
+        }
+        const promise = this.admit(input, requestHash, requestedModel, admitFresh).finally(() => {
+            if (this.starts.get(input.operationId)?.promise === promise)
+                this.starts.delete(input.operationId);
+        });
+        this.starts.set(input.operationId, { requestHash, promise });
+        return promise;
+    }
+    async admit(input, requestHash, requestedModel, admitFresh) {
+        if (this.closed)
+            throw new Error('Authswitch preuse is closing.');
+        const prior = await this.database.readOperation(input.operationId);
+        if (prior) {
+            if (prior.kind !== 'preuse_openai' || prior.accountId !== input.accountId || prior.grantId !== input.loginId
+                || prior.purpose !== input.purpose || prior.requestHash !== requestHash
+                || prior.requestedModel !== requestedModel) {
+                throw new Error('Preuse operation ID belongs to a different request.');
+            }
+            if (prior.state !== 'preparing')
+                return publicOperation(prior);
+            const updateId = plugins.crypto.randomUUID();
+            const interruptedAt = new Date(this.now()).toISOString();
+            return publicOperation(await this.database.changePreuseOperation(updateId, prior.id, current => ({
+                ...current, state: 'not_sent', problem: 'interrupted', updatedAt: interruptedAt,
+                finishedAt: interruptedAt, revision: current.revision + 1, updateId,
+            })));
+        }
+        const context = await this.database.readUsageContext(input.accountId, input.loginId);
+        if (!context || context.providerId !== 'openai' || context.purpose !== input.purpose
+            || context.owner !== 'daemon' || context.removed
+            || !['ready', 'retry_wait'].includes(context.grantState)) {
+            throw new Error('Selected OpenAI login is unavailable for preuse.');
+        }
+        if (this.closed)
+            throw new Error('Authswitch preuse is closing.');
+        const freshAdmission = admitFresh();
+        if (freshAdmission === 'admitted' && this.running.size >= 32) {
+            throw new Error('Too many active preuse operations.');
+        }
+        const now = new Date(this.now()).toISOString();
+        const admitted = await this.database.createPreuseOperation({
+            id: input.operationId, kind: 'preuse_openai', purpose: input.purpose,
+            accountId: input.accountId, grantId: input.loginId, requestHash, requestedModel,
+            model: null, authorizationGeneration: context.authorizationGeneration, grantGeneration: null,
+            state: 'preparing', result: null, problem: 'none', createdAt: now, updatedAt: now,
+            finishedAt: null, revision: 1, updateId: plugins.crypto.randomUUID(),
+        });
+        if (!admitted.created) {
+            if (admitted.operation.state !== 'preparing')
+                return publicOperation(admitted.operation);
+            const updateId = plugins.crypto.randomUUID();
+            const interruptedAt = new Date(this.now()).toISOString();
+            const interrupted = await this.database.changePreuseOperation(updateId, admitted.operation.id, current => ({
+                ...current, state: 'not_sent', problem: 'interrupted', updatedAt: interruptedAt,
+                finishedAt: interruptedAt, revision: current.revision + 1, updateId,
+            }));
+            return publicOperation(interrupted);
+        }
+        if (freshAdmission === 'account_busy') {
+            const updateId = plugins.crypto.randomUUID();
+            const finishedAt = new Date(this.now()).toISOString();
+            const busy = await this.database.changePreuseOperation(updateId, admitted.operation.id, current => ({
+                ...current, state: 'not_sent', problem: 'account_busy', updatedAt: finishedAt,
+                finishedAt, revision: current.revision + 1, updateId,
+            }));
+            return publicOperation(busy);
+        }
+        if (this.closed) {
+            const updateId = plugins.crypto.randomUUID();
+            const closedAt = new Date(this.now()).toISOString();
+            const closed = await this.database.changePreuseOperation(updateId, admitted.operation.id, current => ({
+                ...current, state: 'not_sent', problem: 'authority_closing', updatedAt: closedAt,
+                finishedAt: closedAt, revision: current.revision + 1, updateId,
+            }));
+            return publicOperation(closed);
+        }
+        const controller = new AbortController();
+        const owned = { requestHash, controller, task: Promise.resolve() };
+        this.running.set(input.operationId, owned);
+        owned.task = this.perform(admitted.operation, input.prompt, controller.signal).finally(() => {
+            if (this.running.get(input.operationId) === owned)
+                this.running.delete(input.operationId);
+        });
+        void owned.task.catch(() => { });
+        return publicOperation(admitted.operation);
+    }
+    async perform(operation, prompt, signal) {
+        let phase = 'target';
+        try {
+            signal.throwIfAborted();
+            const context = await this.database.readUsageContext(operation.accountId, operation.grantId);
+            if (!context || context.providerId !== 'openai' || context.purpose !== operation.purpose
+                || context.owner !== 'daemon' || context.removed
+                || context.authorizationGeneration !== operation.authorizationGeneration
+                || !['ready', 'retry_wait'].includes(context.grantState)) {
+                throw new Error('Preuse target changed.');
+            }
+            phase = 'access';
+            const access = await this.broker.resolveUsageAccess(context, undefined, this.minAccessValidityMs);
+            signal.throwIfAborted();
+            phase = operation.requestedModel === null ? 'catalog' : 'access';
+            const credential = {
+                kind: 'chatgptAccess', providerId: 'openai', accessToken: access.accessToken,
+                accountId: access.accountId, isFedrampAccount: access.isFedrampAccount,
+            };
+            const result = await this.executor.runAccess(credential, { prompt, ...(operation.requestedModel === null ? {} : { model: operation.requestedModel }), signal }, { beforeRequest: async (model) => {
+                    signal.throwIfAborted();
+                    await this.database.markPreuseRequestMayHaveStarted(operation.id, plugins.crypto.randomUUID(), model, access.grantGeneration, new Date(this.now()).toISOString());
+                } });
+            const current = await this.readStored(operation.id);
+            if (current.state !== 'request_may_have_started')
+                return;
+            const count = (value) => Number.isSafeInteger(value) && value >= 0 ? value : null;
+            const updateId = plugins.crypto.randomUUID();
+            const now = new Date(this.now()).toISOString();
+            await this.database.changePreuseOperation(updateId, operation.id, prior => ({ ...prior,
+                state: 'complete', result: { inputTokens: count(result.inputTokens), outputTokens: count(result.outputTokens),
+                    totalTokens: count(result.totalTokens) }, problem: 'none', updatedAt: now, finishedAt: now,
+                revision: prior.revision + 1, updateId }));
+        }
+        catch {
+            await this.fail(operation.id, phase, signal);
+        }
+    }
+    async fail(operationId, phase, signal) {
+        let current;
+        try {
+            current = await this.readStored(operationId);
+        }
+        catch {
+            return;
+        }
+        if (!['preparing', 'request_may_have_started'].includes(current.state))
+            return;
+        const marked = current.state === 'request_may_have_started';
+        const problem = marked
+            ? this.closed ? 'authority_closing' : signal.aborted ? 'cancelled' : 'request_uncertain'
+            : this.closed ? 'authority_closing' : signal.aborted ? 'cancelled'
+                : phase === 'target' ? 'target_unavailable' : phase === 'catalog' ? 'catalog_unavailable' : 'access_unavailable';
+        const updateId = plugins.crypto.randomUUID();
+        const now = new Date(this.now()).toISOString();
+        try {
+            await this.database.changePreuseOperation(updateId, operationId, prior => ({ ...prior,
+                state: marked ? 'outcome_unknown' : 'not_sent', problem,
+                updatedAt: now, finishedAt: now, revision: prior.revision + 1, updateId }));
+        }
+        catch { /* A durable request marker remains recoverable as outcome_unknown on restart. */ }
+    }
+    async readStored(operationId) {
+        if (!uuid(operationId))
+            throw new Error('Invalid preuse operation ID.');
+        const operation = await this.database.readOperation(operationId);
+        if (!operation || operation.kind !== 'preuse_openai')
+            throw new Error('Preuse operation was not found.');
+        return operation;
+    }
+    async get(operationId) {
+        return publicOperation(await this.readStored(operationId));
+    }
+    async cancel(operationId) {
+        let current = await this.readStored(operationId);
+        if (!['preparing', 'request_may_have_started'].includes(current.state))
+            return publicOperation(current);
+        this.running.get(operationId)?.controller.abort(new Error('Preuse cancelled.'));
+        const updateId = plugins.crypto.randomUUID();
+        const now = new Date(this.now()).toISOString();
+        try {
+            current = await this.database.changePreuseOperation(updateId, operationId, prior => ({ ...prior,
+                state: prior.state === 'preparing' ? 'not_sent' : 'outcome_unknown', problem: 'cancelled',
+                updatedAt: now, finishedAt: now, revision: prior.revision + 1, updateId }));
+        }
+        catch {
+            current = await this.readStored(operationId);
+            if (['preparing', 'request_may_have_started'].includes(current.state))
+                throw new Error('Preuse cancellation outcome is unknown.');
+        }
+        return publicOperation(current);
+    }
+    async wait(operationId) {
+        const starting = this.starts.get(operationId);
+        if (starting)
+            await starting.promise;
+        const running = this.running.get(operationId);
+        if (running)
+            await running.task;
+    }
+    hasActive(operationId) {
+        return this.starts.has(operationId) || this.running.has(operationId);
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        await Promise.allSettled([...this.starts.values()].map(item => item.promise));
+        for (const running of this.running.values())
+            running.controller.abort(new Error('Authswitch authority is closing.'));
+        await Promise.allSettled([...this.running.values()].map(item => item.task));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.authoritypreuse.js","sourceRoot":"","sources":["../ts/classes.authoritypreuse.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.authorityregistry.d.ts

@@ -0,0 +1,9 @@
+import * as plugins from './plugins.js';
+interface IAuthorityModelEntry {
+    readonly name: string;
+    initialize(db: plugins.nosqldb.SmartdataDb): Promise<void>;
+    prepare(): Promise<void>;
+}
+/** The sole authority collection inventory: startup admits exactly these collections and prepares each one. */
+export declare const authorityModelRegistry: readonly IAuthorityModelEntry[];
+export {};

package/dist_ts/classes.authorityregistry.js

@@ -0,0 +1,32 @@
+import * as plugins from './plugins.js';
+import { AuthSwitchAuthorityAccountModel, AuthSwitchAuthorityBindingModel, AuthSwitchAuthorityClaudeHandoffModel, AuthSwitchAuthorityClaudeHomeModel, AuthSwitchAuthorityCodexHomeModel, AuthSwitchAuthorityEnrollmentModel, AuthSwitchAuthorityEventModel, AuthSwitchAuthorityGrantModel, AuthSwitchAuthorityHandoffModel, AuthSwitchAuthorityMetaModel, AuthSwitchAuthorityMigrationLedgerModel, AuthSwitchAuthorityOperationModel, AuthSwitchAuthorityUsageModel, } from './classes.authoritymodels.js';
+const define = (name, model) => Object.freeze({
+    name,
+    initialize: async (db) => {
+        plugins.nosqldb.setDefaultManagerForDoc({ db }, model);
+        await model.init();
+    },
+    prepare: () => model.exact.prepare(),
+});
+/** The sole authority collection inventory: startup admits exactly these collections and prepares each one. */
+export const authorityModelRegistry = Object.freeze([
+    define('authswitch_authority_accounts', AuthSwitchAuthorityAccountModel),
+    define('authswitch_authority_bindings', AuthSwitchAuthorityBindingModel),
+    define('authswitch_authority_claude_handoffs', AuthSwitchAuthorityClaudeHandoffModel),
+    define('authswitch_authority_claude_homes', AuthSwitchAuthorityClaudeHomeModel),
+    define('authswitch_authority_codex_homes', AuthSwitchAuthorityCodexHomeModel),
+    define('authswitch_authority_enrollments', AuthSwitchAuthorityEnrollmentModel),
+    define('authswitch_authority_events', AuthSwitchAuthorityEventModel),
+    define('authswitch_authority_grants', AuthSwitchAuthorityGrantModel),
+    define('authswitch_authority_handoffs', AuthSwitchAuthorityHandoffModel),
+    define('authswitch_authority_meta', AuthSwitchAuthorityMetaModel),
+    define('authswitch_authority_migration_ledger', AuthSwitchAuthorityMigrationLedgerModel),
+    define('authswitch_authority_operations', AuthSwitchAuthorityOperationModel),
+    define('authswitch_authority_usage', AuthSwitchAuthorityUsageModel),
+]);
+for (let index = 1; index < authorityModelRegistry.length; index++) {
+    if (authorityModelRegistry[index - 1].name >= authorityModelRegistry[index].name) {
+        throw new Error('Authority model registry must be unique and sorted.');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/classes.authoritysecrets.d.ts

@@ -2,7 +2,7 @@ export interface IAuthSwitchSecretCodec {
     seal(accountId: string, plaintext: Uint8Array): Promise<string>;
     unseal(accountId: string, ciphertext: string): Promise<Uint8Array>;
 }
-/** TPM-sealed byte payloads live only as ciphertext in SmartData. */
+/** TPM-sealed byte payloads live only as ciphertext in NoSQLDB. */
 export declare class AuthSwitchTpmSecretCodec implements IAuthSwitchSecretCodec {
     seal(accountId: string, plaintext: Uint8Array): Promise<string>;
     unseal(accountId: string, ciphertext: string): Promise<Uint8Array>;

package/dist_ts/classes.authoritysecrets.js

@@ -4,7 +4,7 @@ const secretName = (accountId) => {
         throw new Error('Invalid account identity for secret custody.');
     return `authswitch.account.${accountId}`;
 };
-/** TPM-sealed byte payloads live only as ciphertext in SmartData. */
+/** TPM-sealed byte payloads live only as ciphertext in NoSQLDB. */
 export class AuthSwitchTpmSecretCodec {
     async seal(accountId, plaintext) {
         const ciphertext = await plugins.smartsecret.sealSmartSecretTpm2Credential(secretName(accountId), plaintext);
@@ -27,4 +27,4 @@ export class AuthSwitchTpmSecretCodec {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5hdXRob3JpdHlzZWNyZXRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvY2xhc3Nlcy5hdXRob3JpdHlzZWNyZXRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sY0FBYyxDQUFDO0FBT3hDLE1BQU0sVUFBVSxHQUFHLENBQUMsU0FBaUIsRUFBVSxFQUFFO0lBQy9DLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDO1FBQUUsTUFBTSxJQUFJLEtBQUssQ0FBQyw4Q0FBOEMsQ0FBQyxDQUFDO0lBQ3ZHLE9BQU8sc0JBQXNCLFNBQVMsRUFBRSxDQUFDO0FBQzNDLENBQUMsQ0FBQztBQUVGLHFFQUFxRTtBQUNyRSxNQUFNLE9BQU8sd0JBQXdCO0lBQzVCLEtBQUssQ0FBQyxJQUFJLENBQUMsU0FBaUIsRUFBRSxTQUFxQjtRQUN4RCxNQUFNLFVBQVUsR0FBRyxNQUFNLE9BQU8sQ0FBQyxXQUFXLENBQUMsNkJBQTZCLENBQUMsVUFBVSxDQUFDLFNBQVMsQ0FBQyxFQUFFLFNBQVMsQ0FBQyxDQUFDO1FBQzdHLElBQUksQ0FBQztZQUFDLE9BQU8sTUFBTSxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsQ0FBQyxRQUFRLENBQUMsV0FBVyxDQUFDLENBQUM7UUFBQyxDQUFDO2dCQUNyRCxDQUFDO1lBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUFDLENBQUM7SUFDakMsQ0FBQztJQUVNLEtBQUssQ0FBQyxNQUFNLENBQUMsU0FBaUIsRUFBRSxVQUFrQjtRQUN2RCxJQUFJLENBQUMsMkJBQTJCLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQztZQUFFLE1BQU0sSUFBSSxLQUFLLENBQUMsb0NBQW9DLENBQUMsQ0FBQztRQUN6RyxNQUFNLEtBQUssR0FBRyxNQUFNLENBQUMsSUFBSSxDQUFDLFVBQVUsRUFBRSxXQUFXLENBQUMsQ0FBQztRQUNuRCxJQUFJLENBQUM7WUFBQyxPQUFPLE1BQU0sT0FBTyxDQUFDLFdBQVcsQ0FBQywrQkFBK0IsQ0FBQyxVQUFVLENBQUMsU0FBUyxDQUFDLEVBQUUsS0FBSyxDQUFDLENBQUM7UUFBQyxDQUFDO2dCQUMvRixDQUFDO1lBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUFDLENBQUM7SUFDNUIsQ0FBQztDQUNGIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5hdXRob3JpdHlzZWNyZXRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvY2xhc3Nlcy5hdXRob3JpdHlzZWNyZXRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sY0FBYyxDQUFDO0FBT3hDLE1BQU0sVUFBVSxHQUFHLENBQUMsU0FBaUIsRUFBVSxFQUFFO0lBQy9DLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDO1FBQUUsTUFBTSxJQUFJLEtBQUssQ0FBQyw4Q0FBOEMsQ0FBQyxDQUFDO0lBQ3ZHLE9BQU8sc0JBQXNCLFNBQVMsRUFBRSxDQUFDO0FBQzNDLENBQUMsQ0FBQztBQUVGLG1FQUFtRTtBQUNuRSxNQUFNLE9BQU8sd0JBQXdCO0lBQzVCLEtBQUssQ0FBQyxJQUFJLENBQUMsU0FBaUIsRUFBRSxTQUFxQjtRQUN4RCxNQUFNLFVBQVUsR0FBRyxNQUFNLE9BQU8sQ0FBQyxXQUFXLENBQUMsNkJBQTZCLENBQUMsVUFBVSxDQUFDLFNBQVMsQ0FBQyxFQUFFLFNBQVMsQ0FBQyxDQUFDO1FBQzdHLElBQUksQ0FBQztZQUFDLE9BQU8sTUFBTSxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsQ0FBQyxRQUFRLENBQUMsV0FBVyxDQUFDLENBQUM7UUFBQyxDQUFDO2dCQUNyRCxDQUFDO1lBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUFDLENBQUM7SUFDakMsQ0FBQztJQUVNLEtBQUssQ0FBQyxNQUFNLENBQUMsU0FBaUIsRUFBRSxVQUFrQjtRQUN2RCxJQUFJLENBQUMsMkJBQTJCLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQztZQUFFLE1BQU0sSUFBSSxLQUFLLENBQUMsb0NBQW9DLENBQUMsQ0FBQztRQUN6RyxNQUFNLEtBQUssR0FBRyxNQUFNLENBQUMsSUFBSSxDQUFDLFVBQVUsRUFBRSxXQUFXLENBQUMsQ0FBQztRQUNuRCxJQUFJLENBQUM7WUFBQyxPQUFPLE1BQU0sT0FBTyxDQUFDLFdBQVcsQ0FBQywrQkFBK0IsQ0FBQyxVQUFVLENBQUMsU0FBUyxDQUFDLEVBQUUsS0FBSyxDQUFDLENBQUM7UUFBQyxDQUFDO2dCQUMvRixDQUFDO1lBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUFDLENBQUM7SUFDNUIsQ0FBQztDQUNGIn0=

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 NoSQLDB 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 NoSQLDB 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 NoSQLDB 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 {};