@modelprofile.com/authswitch 6.4.0 → 7.0.0

package/ts/classes.authoritypreuse.ts

@@ -0,0 +1,297 @@
+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 { IStoredAuthorityPreuseOperation, TStoredAuthorityPreuseProblem } from './classes.authoritymodels.js';
+import { CodexPreuse, type ICodexPreuseLifecycle } from './classes.codexpreuse.js';
+import type { IHarnessPreuseOptions, IHarnessPreuseResult } from './interfaces.harness.js';
+import { validatePreuseOptions } from './preuse.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';
+
+interface IRunningPreuse {
+  requestHash: string;
+  controller: AbortController;
+  task: Promise<void>;
+}
+
+const uuid = (value: unknown): value is string => typeof value === 'string' && /^[a-f0-9-]{36}$/.test(value);
+const hash = (value: unknown): value is string => typeof value === 'string' && /^[a-f0-9]{64}$/.test(value);
+const publicOperation = (operation: IStoredAuthorityPreuseOperation): IAuthSwitchPreuseOperation => ({
+  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 {
+  private readonly executor: IAuthSwitchAuthorityPreuseExecutor;
+  private readonly now: () => number;
+  private readonly minAccessValidityMs: number;
+  private readonly starts = new Map<string, { requestHash: string; promise: Promise<IAuthSwitchPreuseOperation> }>();
+  private readonly running = new Map<string, IRunningPreuse>();
+  private closed = false;
+
+  constructor(private readonly database: AuthSwitchAuthorityDatabase,
+    private readonly broker: AuthSwitchAuthorityBroker, options: IAuthSwitchAuthorityPreuseOptions = {}) {
+    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. */
+  public async start(): Promise<void> {
+    for (const state of ['preparing', 'request_may_have_started'] as const) {
+      let after: string | null = 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;
+      }
+    }
+  }
+
+  public begin(input: IAuthSwitchAuthorityPreuseRequest,
+    admitFresh: TAuthSwitchAuthorityPreuseFreshAdmission): Promise<IAuthSwitchPreuseOperation> {
+    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;
+  }
+
+  private async admit(input: IAuthSwitchAuthorityPreuseRequest, requestHash: string,
+    requestedModel: string | null,
+    admitFresh: TAuthSwitchAuthorityPreuseFreshAdmission): Promise<IAuthSwitchPreuseOperation> {
+    await this.database.assertOpenAdmission();
+    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: IRunningPreuse = { 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);
+  }
+
+  private async perform(operation: IStoredAuthorityPreuseOperation, prompt: string, signal: AbortSignal): Promise<void> {
+    let phase: 'target' | 'access' | 'catalog' = '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: plugins.flexAccounts.IOpenAiChatGptAccessCredential = {
+        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 | undefined): number | null => 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);
+    }
+  }
+
+  private async fail(operationId: string, phase: 'target' | 'access' | 'catalog', signal: AbortSignal): Promise<void> {
+    let current: IStoredAuthorityPreuseOperation;
+    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: TStoredAuthorityPreuseProblem = 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. */ }
+  }
+
+  private async readStored(operationId: string): Promise<IStoredAuthorityPreuseOperation> {
+    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;
+  }
+
+  public async get(operationId: string): Promise<IAuthSwitchPreuseOperation> {
+    return publicOperation(await this.readStored(operationId));
+  }
+
+  public async cancel(operationId: string): Promise<IAuthSwitchPreuseOperation> {
+    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);
+  }
+
+  public async wait(operationId: string): Promise<void> {
+    const starting = this.starts.get(operationId);
+    if (starting) await starting.promise;
+    const running = this.running.get(operationId);
+    if (running) await running.task;
+  }
+
+  public hasActive(operationId: string): boolean {
+    return this.starts.has(operationId) || this.running.has(operationId);
+  }
+
+  public async close(): Promise<void> {
+    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));
+  }
+}

package/ts/classes.authorityregistry.ts

@@ -0,0 +1,118 @@
+import * as plugins from './plugins.js';
+import {
+  AuthSwitchAuthorityAccountModel, AuthSwitchAuthorityBindingModel, AuthSwitchAuthorityClaudeHandoffModel,
+  AuthSwitchAuthorityClaudeHomeModel, AuthSwitchAuthorityCodexHomeModel, AuthSwitchAuthorityEnrollmentModel,
+  AuthSwitchAuthorityEventModel, AuthSwitchAuthorityGrantModel, AuthSwitchAuthorityHandoffModel,
+  AuthSwitchAuthorityMetaModel, AuthSwitchAuthorityMigrationLedgerModel, AuthSwitchAuthorityOperationModel,
+  AuthSwitchAuthorityUsageModel, assertStoredAuthorityAccount, assertStoredAuthorityBinding,
+  assertStoredAuthorityClaudeHandoff, assertStoredAuthorityClaudeHome, assertStoredAuthorityCodexHome,
+  assertStoredAuthorityEnrollment, assertStoredAuthorityEvent, assertStoredAuthorityGrant,
+  assertStoredAuthorityHandoff, assertStoredAuthorityMeta, assertStoredAuthorityMigrationLedger,
+  assertStoredAuthorityOperationDocument, assertStoredAuthorityUsage,
+} from './classes.authoritymodels.js';
+
+export interface IAuthorityStoredRecord { model: string; id: string; value: unknown }
+
+interface IAuthorityModelEntry {
+  readonly name: string;
+  initialize(db: plugins.smartdata.SmartdataDb): Promise<void>;
+  prepare(): Promise<void>;
+  assert(value: unknown): void;
+  page(after: string | null, limit: number, session?: plugins.smartdata.SmartdataSession,
+    signal?: AbortSignal): Promise<IAuthorityStoredRecord[]>;
+  insert(record: IAuthorityStoredRecord, session?: plugins.smartdata.SmartdataSession): Promise<void>;
+}
+
+const define = <TPersisted extends { id: string },
+  TModel extends TPersisted & plugins.smartdata.SmartDataDbDoc<TModel, TPersisted>>(
+    name: string,
+    model: { new(): TModel; init(): Promise<void>; exact: plugins.smartdata.TExact<TModel> },
+    assertDocument: (value: unknown) => asserts value is TPersisted,
+  ): IAuthorityModelEntry => Object.freeze({
+    name,
+    initialize: async (db: plugins.smartdata.SmartdataDb) => {
+      plugins.smartdata.setDefaultManagerForDoc({ db }, model);
+      await model.init();
+    },
+    prepare: () => model.exact.prepare(),
+    assert: (value: unknown) => { assertDocument(value); },
+    page: async (after: string | null, limit: number, session?: plugins.smartdata.SmartdataSession,
+      signal?: AbortSignal): Promise<IAuthorityStoredRecord[]> => {
+      const query = {
+        filter: after === null ? {} : { id: { $gt: after } }, sort: { id: 1 }, limit, session, signal,
+      } as Parameters<typeof model.exact.findStored>[0];
+      const stored = await model.exact.findStored(query);
+      return stored.map(item => {
+        const value = model.exact.toPersisted(item);
+        return { model: name, id: value.id, value };
+      });
+    },
+    insert: async (record: IAuthorityStoredRecord, session?: plugins.smartdata.SmartdataSession): Promise<void> => {
+      assertDocument(record.value);
+      if (record.value.id !== record.id) throw new Error('Authority restore record identity differs from its key.');
+      const result = await model.exact.insert(record.value as unknown as Parameters<typeof model.exact.insert>[0],
+        { session });
+      if (result.status !== 'inserted') throw new Error('Authority restore record already exists.');
+    },
+  });
+
+/** The sole authority collection inventory, in portable model+stable-ID order. */
+export const authorityModelRegistry: readonly IAuthorityModelEntry[] = Object.freeze([
+  define('authswitch_authority_accounts', AuthSwitchAuthorityAccountModel, assertStoredAuthorityAccount),
+  define('authswitch_authority_bindings', AuthSwitchAuthorityBindingModel, assertStoredAuthorityBinding),
+  define('authswitch_authority_claude_handoffs', AuthSwitchAuthorityClaudeHandoffModel, assertStoredAuthorityClaudeHandoff),
+  define('authswitch_authority_claude_homes', AuthSwitchAuthorityClaudeHomeModel, assertStoredAuthorityClaudeHome),
+  define('authswitch_authority_codex_homes', AuthSwitchAuthorityCodexHomeModel, assertStoredAuthorityCodexHome),
+  define('authswitch_authority_enrollments', AuthSwitchAuthorityEnrollmentModel, assertStoredAuthorityEnrollment),
+  define('authswitch_authority_events', AuthSwitchAuthorityEventModel, assertStoredAuthorityEvent),
+  define('authswitch_authority_grants', AuthSwitchAuthorityGrantModel, assertStoredAuthorityGrant),
+  define('authswitch_authority_handoffs', AuthSwitchAuthorityHandoffModel, assertStoredAuthorityHandoff),
+  define('authswitch_authority_meta', AuthSwitchAuthorityMetaModel, assertStoredAuthorityMeta),
+  define('authswitch_authority_migration_ledger', AuthSwitchAuthorityMigrationLedgerModel, assertStoredAuthorityMigrationLedger),
+  define('authswitch_authority_operations', AuthSwitchAuthorityOperationModel, assertStoredAuthorityOperationDocument),
+  define('authswitch_authority_usage', AuthSwitchAuthorityUsageModel, assertStoredAuthorityUsage),
+]);
+
+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.');
+  }
+}
+
+export const authorityModel = (name: string): IAuthorityModelEntry => {
+  const entry = authorityModelRegistry.find(item => item.name === name);
+  if (!entry) throw new Error('Unclassified authority model cannot be read, backed up or restored.');
+  return entry;
+};
+
+export const assertAuthorityStoredRecord = (record: IAuthorityStoredRecord): void => {
+  if (!record || typeof record.model !== 'string' || typeof record.id !== 'string' || !record.id) {
+    throw new Error('Invalid authority record identity.');
+  }
+  authorityModel(record.model).assert(record.value);
+  if (!record.value || typeof record.value !== 'object' || !('id' in record.value)
+    || record.value.id !== record.id) throw new Error('Invalid authority record identity.');
+};
+
+export async function* authorityStoredRecords(options: {
+  session?: plugins.smartdata.SmartdataSession; signal?: AbortSignal; pageSize?: number;
+} = {}): AsyncGenerator<IAuthorityStoredRecord> {
+  const pageSize = options.pageSize ?? 64;
+  if (!Number.isSafeInteger(pageSize) || pageSize < 1 || pageSize > 256) {
+    throw new Error('Invalid authority record page size.');
+  }
+  for (const entry of authorityModelRegistry) {
+    let after: string | null = null;
+    while (true) {
+      options.signal?.throwIfAborted();
+      const page = await entry.page(after, pageSize, options.session, options.signal);
+      if (!page.length) break;
+      for (const record of page) {
+        assertAuthorityStoredRecord(record);
+        yield record;
+      }
+      after = page[page.length - 1].id;
+      if (page.length < pageSize) break;
+    }
+  }
+}