@modelprofile.com/authswitch-signin 10.4.0

package/dist_ts_signin/signin.grants.js

@@ -0,0 +1,408 @@
+// OpenAI protocol portions are adapted in TypeScript from OpenAI Codex (Apache-2.0) and modified by Task Venture Capital GmbH; see third-party-notices.md.
+import * as plugins from './plugins.js';
+import { parseOpenAiTokenClaims, revokeOpenAiRefreshToken } from './signin.protocol.js';
+import { openAiTokensOfCredential, refreshOpenAiCredential } from './signin.credential.js';
+/** A grant failure. Its message is fixed and names no token. */
+export class OpenAiGrantError extends Error {
+    code;
+    details;
+    constructor(code, details = {}) {
+        super(`OpenAI grant operation failed (${code}).`);
+        this.code = code;
+        this.details = details;
+        this.name = 'OpenAiGrantError';
+    }
+}
+/** Codex refreshes an access token that expires within five minutes (`CHATGPT_ACCESS_TOKEN_REFRESH_WINDOW_MINUTES`). */
+const ACCESS_REFRESH_WINDOW_MS = 5 * 60 * 1000;
+/** Codex refreshes tokens older than eight days even while the access token is valid (`TOKEN_REFRESH_INTERVAL`). */
+const TOKEN_REFRESH_INTERVAL_MS = 8 * 24 * 60 * 60 * 1000;
+/** One refresh request is bounded by thirty seconds; an attempt is given up thirty seconds after that. */
+const REFRESH_REQUEST_TIMEOUT_MS = 30_000;
+const REFRESH_ATTEMPT_LEASE_MS = 60_000;
+const DEFAULT_MIN_VALIDITY_MS = 60_000;
+const MAX_MIN_VALIDITY_MS = 3_600_000;
+const MAX_RESOLVE_ROUNDS = 8;
+const MAX_WRITE_ROUNDS = 4;
+const MAX_GRANT_ID_BYTES = 512;
+const isoTime = (value) => {
+    if (typeof value !== 'string')
+        return NaN;
+    const time = Date.parse(value);
+    return Number.isFinite(time) && new Date(time).toISOString() === value ? time : NaN;
+};
+const isCount = (value, minimum) => typeof value === 'number' && Number.isSafeInteger(value) && value >= minimum;
+const requireGrantId = (grantId) => {
+    if (typeof grantId !== 'string' || !grantId || Buffer.byteLength(grantId, 'utf8') > MAX_GRANT_ID_BYTES) {
+        throw new OpenAiGrantError('invalid_argument');
+    }
+    return grantId;
+};
+/** The identity and expiry a credential's access token states; `null` when it states none of them usable. */
+const accessFactsOf = (credential) => {
+    try {
+        openAiTokensOfCredential(credential);
+        const access = parseOpenAiTokenClaims(credential.accessToken);
+        const identity = parseOpenAiTokenClaims(credential.idToken);
+        const accountId = access.chatgptAccountId ?? identity.chatgptAccountId;
+        const userId = access.chatgptUserId ?? identity.chatgptUserId;
+        if (!accountId || !userId || !access.expiresAt)
+            return null;
+        if (identity.chatgptAccountId !== undefined && identity.chatgptAccountId !== accountId)
+            return null;
+        return { accountId, userId, isFedrampAccount: access.chatgptAccountIsFedramp, expiresAt: access.expiresAt };
+    }
+    catch {
+        return null;
+    }
+};
+/** A stored record this manager would have written; anything else is refused before it is used. */
+const checkRecord = (record) => {
+    const valid = record !== null && typeof record === 'object'
+        && isCount(record.revision, 1) && isCount(record.generation, 1) && isCount(record.retryCount, 0)
+        && ['active', 'refresh_uncertain', 'reauth_required'].includes(record.state)
+        && typeof record.accountId === 'string' && record.accountId.length > 0
+        && typeof record.userId === 'string' && record.userId.length > 0
+        && typeof record.isFedrampAccount === 'boolean'
+        && Number.isFinite(isoTime(record.accessExpiresAt)) && Number.isFinite(isoTime(record.refreshedAt))
+        && (record.retryAt === null || Number.isFinite(isoTime(record.retryAt)))
+        && (record.state === 'refresh_uncertain'
+            ? record.attempt !== null && typeof record.attempt === 'object' && typeof record.attempt.id === 'string'
+                && record.attempt.id.length > 0 && Number.isFinite(isoTime(record.attempt.expiresAt))
+            : record.attempt === null)
+        && (record.state === 'reauth_required'
+            ? ['refresh_failed', 'refresh_interrupted', 'identity_changed'].includes(record.reauthReason ?? '')
+            : record.reauthReason === null);
+    if (!valid)
+        throw new OpenAiGrantError('invalid_record');
+    const facts = accessFactsOf(record.credential);
+    if (!facts || facts.accountId !== record.accountId || facts.userId !== record.userId
+        || facts.isFedrampAccount !== record.isFedrampAccount || facts.expiresAt !== record.accessExpiresAt) {
+        throw new OpenAiGrantError('invalid_record');
+    }
+    return record;
+};
+/**
+ * Keeps ChatGPT sign-ins usable for any number of processes that share one store: it answers current access for
+ * each request, refreshes the tokens when they are due or the provider rejected exactly the current generation,
+ * and never sends a refresh token whose outcome is unknown a second time. Within a process one refresh per grant
+ * runs at a time; across processes the store's compare-and-set on the revision decides, and a process that finds
+ * another's refresh in flight waits for its outcome. It holds no credential of its own: every call reads the
+ * store, and no error, status or return value carries a refresh or ID token.
+ */
+export class OpenAiGrantManager {
+    store;
+    fetcher;
+    now;
+    waitIntervalMs;
+    refreshes = new Map();
+    constructor(options) {
+        if (!options || typeof options.store !== 'object' || options.store === null) {
+            throw new OpenAiGrantError('invalid_argument');
+        }
+        const waitIntervalMs = options.waitIntervalMs ?? 250;
+        if (!Number.isSafeInteger(waitIntervalMs) || waitIntervalMs < 1 || waitIntervalMs > 10_000) {
+            throw new OpenAiGrantError('invalid_argument');
+        }
+        this.store = options.store;
+        this.fetcher = options.fetch;
+        this.now = options.now ?? (() => Date.now());
+        this.waitIntervalMs = waitIntervalMs;
+    }
+    /** The record a new sign-in starts: generation one, active. */
+    recordOf(result, revision, generation) {
+        const facts = result && typeof result === 'object' ? accessFactsOf(result.credential) : null;
+        if (!facts)
+            throw new OpenAiGrantError('invalid_argument');
+        return {
+            revision, generation, state: 'active', credential: result.credential,
+            accountId: facts.accountId, userId: facts.userId, isFedrampAccount: facts.isFedrampAccount,
+            accessExpiresAt: facts.expiresAt, refreshedAt: new Date(this.now()).toISOString(),
+            retryAt: null, retryCount: 0, attempt: null, reauthReason: null,
+        };
+    }
+    statusOf(record) {
+        let plan = null;
+        try {
+            plan = parseOpenAiTokenClaims(record.credential.idToken).chatgptPlanType ?? null;
+        }
+        catch {
+            plan = null;
+        }
+        return {
+            revision: record.revision, generation: record.generation, state: record.state,
+            reauthReason: record.reauthReason, accountId: record.accountId, isFedrampAccount: record.isFedrampAccount,
+            plan, accessExpiresAt: record.accessExpiresAt, refreshedAt: record.refreshedAt, retryAt: record.retryAt,
+        };
+    }
+    async load(grantId) {
+        const record = await this.store.load(grantId);
+        return record === null ? null : checkRecord(record);
+    }
+    /** Stores the grant a device sign-in produced. Throws `OpenAiGrantError` `contended` when a grant exists under the id. */
+    async create(grantId, result) {
+        requireGrantId(grantId);
+        const record = this.recordOf(result, 1, 1);
+        if (await this.store.create(grantId, record) !== 'stored')
+            throw new OpenAiGrantError('contended');
+        return this.statusOf(record);
+    }
+    /**
+     * Replaces a grant with a new sign-in, over the revision the caller read: a grant that needs a new sign-in is
+     * repaired this way. The generation keeps rising, so a 401 of the old tokens cannot be mistaken for the new.
+     * The replaced tokens are not revoked.
+     */
+    async replace(grantId, expectedRevision, result) {
+        requireGrantId(grantId);
+        if (!isCount(expectedRevision, 1))
+            throw new OpenAiGrantError('invalid_argument');
+        const current = await this.load(grantId);
+        if (!current)
+            throw new OpenAiGrantError('not_found');
+        if (current.revision !== expectedRevision)
+            throw new OpenAiGrantError('contended');
+        const record = this.recordOf(result, current.revision + 1, current.generation + 1);
+        if (await this.store.compareAndSet(grantId, expectedRevision, record) !== 'stored') {
+            throw new OpenAiGrantError('contended');
+        }
+        return this.statusOf(record);
+    }
+    /** The grant's state without any token; `null` when there is none. */
+    async status(grantId) {
+        requireGrantId(grantId);
+        const record = await this.load(grantId);
+        return record ? this.statusOf(record) : null;
+    }
+    isDue(record, minValidityMs) {
+        const now = this.now();
+        return Date.parse(record.accessExpiresAt) <= now + Math.max(minValidityMs, ACCESS_REFRESH_WINDOW_MS)
+            || Date.parse(record.refreshedAt) <= now - TOKEN_REFRESH_INTERVAL_MS;
+    }
+    async wait(signal) {
+        if (signal?.aborted)
+            throw new OpenAiGrantError('aborted');
+        let timer;
+        let onAbort;
+        try {
+            await new Promise((resolve, reject) => {
+                timer = setTimeout(resolve, this.waitIntervalMs);
+                if (signal) {
+                    onAbort = () => reject(new OpenAiGrantError('aborted'));
+                    signal.addEventListener('abort', onAbort, { once: true });
+                }
+            });
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+            if (onAbort)
+                signal?.removeEventListener('abort', onAbort);
+        }
+    }
+    /** Waits for a promise, or rejects `aborted` as soon as the signal fires; the promise runs on regardless. */
+    async awaitOrAbort(task, signal) {
+        if (!signal)
+            return task;
+        if (signal.aborted)
+            throw new OpenAiGrantError('aborted');
+        let onAbort;
+        try {
+            await Promise.race([task, new Promise((_resolve, reject) => {
+                    onAbort = () => reject(new OpenAiGrantError('aborted'));
+                    signal.addEventListener('abort', onAbort, { once: true });
+                })]);
+        }
+        finally {
+            if (onAbort)
+                signal.removeEventListener('abort', onAbort);
+        }
+    }
+    /** Moves a record on over the revision it was read at; `false` when it moved meanwhile. */
+    async write(grantId, current, change) {
+        const next = { ...current, ...change, revision: current.revision + 1 };
+        return await this.store.compareAndSet(grantId, current.revision, next) === 'stored';
+    }
+    /**
+     * Current access for one provider request. The access stays valid for `minValidityMs` at least; tokens that
+     * are due, or whose generation the provider just rejected, are refreshed first.
+     * Throws `OpenAiGrantError`: `reauth_required` when only a new sign-in helps, `access_not_fresh` when the
+     * service could not renew the tokens yet.
+     */
+    async resolveAccess(grantId, options = {}) {
+        requireGrantId(grantId);
+        const minValidityMs = options.minValidityMs ?? DEFAULT_MIN_VALIDITY_MS;
+        const rejected = options.rejectedGeneration;
+        if (!Number.isSafeInteger(minValidityMs) || minValidityMs < 0 || minValidityMs > MAX_MIN_VALIDITY_MS
+            || (rejected !== undefined && !isCount(rejected, 1))) {
+            throw new OpenAiGrantError('invalid_argument');
+        }
+        let refreshedOnce = false;
+        for (let round = 0; round < MAX_RESOLVE_ROUNDS; round++) {
+            if (options.signal?.aborted)
+                throw new OpenAiGrantError('aborted');
+            const record = await this.load(grantId);
+            if (!record)
+                throw new OpenAiGrantError('not_found');
+            if (rejected !== undefined && rejected > record.generation)
+                throw new OpenAiGrantError('invalid_argument');
+            if (record.state === 'reauth_required') {
+                throw new OpenAiGrantError('reauth_required', { reauthReason: record.reauthReason ?? 'refresh_failed' });
+            }
+            if (record.state === 'refresh_uncertain') {
+                await this.settleAttempt(grantId, record, options.signal);
+                continue;
+            }
+            const rejectedCurrent = rejected === record.generation;
+            const expiresAt = Date.parse(record.accessExpiresAt);
+            const usable = !rejectedCurrent && expiresAt > this.now() + minValidityMs;
+            if (!this.isDue(record, minValidityMs) && usable) {
+                return {
+                    accessToken: record.credential.accessToken, accountId: record.accountId,
+                    isFedrampAccount: record.isFedrampAccount, expiresAt: record.accessExpiresAt, generation: record.generation,
+                };
+            }
+            const retryAt = record.retryAt === null ? null : Date.parse(record.retryAt);
+            if (refreshedOnce || (retryAt !== null && retryAt > this.now())) {
+                // The service was asked and could not renew the tokens yet. Access that is still good enough serves.
+                if (usable) {
+                    return {
+                        accessToken: record.credential.accessToken, accountId: record.accountId,
+                        isFedrampAccount: record.isFedrampAccount, expiresAt: record.accessExpiresAt, generation: record.generation,
+                    };
+                }
+                throw new OpenAiGrantError('access_not_fresh', record.retryAt === null ? {} : { retryAt: record.retryAt });
+            }
+            await this.awaitOrAbort(this.refresh(grantId, record), options.signal);
+            refreshedOnce = true;
+        }
+        throw new OpenAiGrantError('contended');
+    }
+    /**
+     * Refreshes a grant that is due (by its access expiry or its age) and answers its state; one that is not due is
+     * left as it is. For a periodic job, so a sign-in that no request uses stays alive.
+     */
+    async keepFresh(grantId, options = {}) {
+        requireGrantId(grantId);
+        try {
+            await this.resolveAccess(grantId, { signal: options.signal, minValidityMs: 0 });
+        }
+        catch (error) {
+            if (!(error instanceof OpenAiGrantError) || !['reauth_required', 'access_not_fresh', 'not_found'].includes(error.code)) {
+                throw error;
+            }
+        }
+        return this.status(grantId);
+    }
+    /**
+     * A record whose refresh may have been sent: this process waits for its own attempt; another process's attempt
+     * is waited for until the record moves on or the attempt's lease passes, and then the grant needs a new sign-in.
+     */
+    async settleAttempt(grantId, record, signal) {
+        const own = this.refreshes.get(grantId);
+        if (own) {
+            await this.awaitOrAbort(own, signal);
+            return;
+        }
+        let current = record;
+        while (current && current.revision === record.revision) {
+            if (!current.attempt || Date.parse(current.attempt.expiresAt) <= this.now()) {
+                await this.write(grantId, current, {
+                    state: 'reauth_required', reauthReason: 'refresh_interrupted', attempt: null, retryAt: null,
+                });
+                return;
+            }
+            await this.wait(signal);
+            current = await this.load(grantId);
+        }
+    }
+    /** One refresh per grant in this process; a caller that stops waiting leaves it running to its end. */
+    refresh(grantId, record) {
+        const prior = this.refreshes.get(grantId);
+        if (prior)
+            return prior;
+        const task = this.performRefresh(grantId, record)
+            .finally(() => { if (this.refreshes.get(grantId) === task)
+            this.refreshes.delete(grantId); });
+        this.refreshes.set(grantId, task);
+        return task;
+    }
+    async performRefresh(grantId, initial) {
+        const attemptId = plugins.crypto.randomUUID();
+        const attempt = { id: attemptId, expiresAt: new Date(this.now() + REFRESH_ATTEMPT_LEASE_MS).toISOString() };
+        // The marker is stored before the refresh token is sent: a process that dies after this point leaves a
+        // record that can only lead to a new sign-in, never to a second use of the same refresh token.
+        if (!await this.write(grantId, initial, { state: 'refresh_uncertain', attempt, retryAt: null }))
+            return;
+        const marked = { ...initial, state: 'refresh_uncertain', attempt, retryAt: null,
+            revision: initial.revision + 1 };
+        const result = await refreshOpenAiCredential(initial.credential, {
+            fetch: this.fetcher, signal: AbortSignal.timeout(REFRESH_REQUEST_TIMEOUT_MS), now: () => new Date(this.now()),
+        });
+        const current = await this.load(grantId);
+        if (!current || current.revision !== marked.revision || current.attempt?.id !== attemptId)
+            return;
+        if (result.success) {
+            const facts = accessFactsOf(result.credential);
+            if (!facts || facts.accountId !== initial.accountId || facts.userId !== initial.userId) {
+                await this.write(grantId, current, {
+                    state: 'reauth_required', reauthReason: 'identity_changed', attempt: null, retryAt: null,
+                });
+                return;
+            }
+            await this.write(grantId, current, {
+                state: 'active', credential: result.credential, generation: current.generation + 1,
+                isFedrampAccount: facts.isFedrampAccount, accessExpiresAt: facts.expiresAt,
+                refreshedAt: new Date(this.now()).toISOString(), retryAt: null, retryCount: 0, attempt: null,
+                reauthReason: null,
+            });
+            return;
+        }
+        if (result.requestOutcome === 'notSent') {
+            const backoffMs = Math.min(30_000 * 2 ** Math.min(current.retryCount, 10), 1_800_000);
+            const retryMs = Math.max(backoffMs, Math.min(result.retryAfterMs ?? 0, 3_600_000));
+            await this.write(grantId, current, {
+                state: 'active', attempt: null, retryAt: new Date(this.now() + retryMs).toISOString(),
+                retryCount: current.retryCount + 1,
+            });
+            return;
+        }
+        await this.write(grantId, current, {
+            state: 'reauth_required', reauthReason: 'refresh_failed', attempt: null, retryAt: null,
+        });
+    }
+    /**
+     * Removes a grant and then asks the service to revoke its refresh token. The grant is removed whatever the
+     * service answers; `revocation` says what it answered. `removed: false` when there was no grant.
+     */
+    async remove(grantId, options = {}) {
+        requireGrantId(grantId);
+        for (let round = 0; round < MAX_WRITE_ROUNDS; round++) {
+            const record = await this.store.load(grantId);
+            if (!record)
+                return { removed: false, revocation: null };
+            if (!isCount(record.revision, 1))
+                throw new OpenAiGrantError('invalid_record');
+            if (await this.store.remove(grantId, record.revision) !== 'removed')
+                continue;
+            let token = null;
+            try {
+                token = openAiTokensOfCredential(record.credential).refreshToken;
+            }
+            catch {
+                token = null;
+            }
+            if (token === null)
+                return { removed: true, revocation: 'failed' };
+            try {
+                await revokeOpenAiRefreshToken(token, { fetch: this.fetcher, signal: options.signal });
+            }
+            catch {
+                return { removed: true, revocation: 'failed' };
+            }
+            const current = record.state === 'active' && record.attempt === null;
+            return { removed: true, revocation: current ? 'confirmed' : 'unconfirmed' };
+        }
+        throw new OpenAiGrantError('contended');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signin.grants.js","sourceRoot":"","sources":["../ts_signin/signin.grants.ts"],"names":[],"mappings":"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"}

package/dist_ts_signin/signin.interfaces.d.ts

@@ -0,0 +1,62 @@
+/**
+ * The shapes of one ChatGPT sign-in: the credential it produces, the access that credential grants, what its
+ * claims say about the account, and the outcome of a refresh. Inference with an access token is FlexHarness's
+ * `/openai`, not this.
+ */
+/** Whether a failed request reached the provider: `notSent` never did, `outcomeUnknown` may have. */
+export type TOpenAiRequestOutcome = 'notSent' | 'outcomeUnknown';
+/**
+ * A ChatGPT sign-in with its rotating refresh token. This exact shape is what the authority seals, so a stored
+ * credential keeps reading back across releases.
+ */
+export interface IOpenAiOAuthCredential {
+    kind: 'chatgptOAuth';
+    providerId: 'openai';
+    accessToken: string;
+    refreshToken: string;
+    idToken: string;
+    /** When this credential was last refreshed; strictly increasing across refreshes. */
+    lastRefreshAt?: string;
+}
+/** Access to one ChatGPT workspace, with the workspace and residency its issuer states. */
+export interface IOpenAiAccess {
+    accessToken: string;
+    accountId: string;
+    isFedrampAccount: boolean;
+}
+/** What a sign-in's claims say about its account; no token. */
+export interface IOpenAiAccountSummary {
+    providerId: 'openai';
+    authKind: 'chatgptOAuth';
+    accountId?: string;
+    email?: string;
+    plan?: string;
+}
+/** What the person signing in does: open the URL and enter the code. */
+export interface IOpenAiDevicePrompt {
+    flow: 'device';
+    verificationUrl: string;
+    userCode: string;
+}
+export interface IOpenAiLoginResult {
+    credential: IOpenAiOAuthCredential;
+    account: IOpenAiAccountSummary;
+}
+export type TOpenAiOperationErrorCode = 'ABORTED' | 'TIMEOUT';
+export interface IOpenAiRefreshSuccess {
+    success: true;
+    credential: IOpenAiOAuthCredential;
+    account: IOpenAiAccountSummary;
+}
+export interface IOpenAiRefreshFailure {
+    success: false;
+    credential: IOpenAiOAuthCredential;
+    errorCode: TOpenAiOperationErrorCode | 'REFRESH_FAILED';
+    /** Never replay a rotating grant when this is `outcomeUnknown`. */
+    requestOutcome: TOpenAiRequestOutcome;
+    /** The response status, when an HTTP response was observed. */
+    responseStatus?: number;
+    /** Bounded Retry-After delay from the observed response. */
+    retryAfterMs?: number;
+}
+export type TOpenAiRefreshResult = IOpenAiRefreshSuccess | IOpenAiRefreshFailure;

package/dist_ts_signin/signin.interfaces.js

@@ -0,0 +1,3 @@
+// OpenAI protocol portions are adapted in TypeScript from OpenAI Codex (Apache-2.0) and modified by Task Venture Capital GmbH; see third-party-notices.md.
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2lnbmluLmludGVyZmFjZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c19zaWduaW4vc2lnbmluLmludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsMkpBQTJKIn0=

package/dist_ts_signin/signin.protocol.d.ts

@@ -0,0 +1,93 @@
+import type { TOpenAiRequestOutcome } from './signin.interfaces.js';
+/**
+ * The ChatGPT sign-in protocol Codex uses (`codex-rs/login`: `device_code_auth.rs`, `auth/manager.rs`,
+ * `auth/revoke.rs`, `oauth/client.rs`), for the one party that signs an account in and refreshes it: the device
+ * code, its poll, the authorization-code exchange, the refresh-token grant, the revocation and the claims of the
+ * tokens. Every failure is a fixed message: no response body, token or header crosses an error.
+ */
+export declare const OPENAI_AUTH_ISSUER = "https://auth.openai.com";
+export declare const OPENAI_AUTH_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+/** How long a device code lives: Codex polls it for fifteen minutes and tells the person it expires then. */
+export declare const OPENAI_DEVICE_CODE_LIFETIME_MS: number;
+export declare class OpenAiAuthError extends Error {
+    readonly status?: number;
+    readonly requestOutcome?: TOpenAiRequestOutcome;
+    readonly retryAfterMs?: number;
+    constructor(message: string, options?: {
+        status?: number;
+        requestOutcome?: TOpenAiRequestOutcome;
+        retryAfterMs?: number;
+    });
+}
+export interface IOpenAiAuthOptions {
+    fetch?: typeof fetch;
+    /** Aborts network requests and device-code polling. */
+    signal?: AbortSignal;
+}
+export interface IOpenAiDeviceCodePollOptions extends IOpenAiAuthOptions {
+    timeoutMs?: number;
+    sleep?: (ms: number) => Promise<void>;
+}
+/** What the claims of a ChatGPT token say about its account; never the token itself. */
+export interface IOpenAiTokenClaims {
+    email?: string;
+    chatgptPlanType?: string;
+    chatgptUserId?: string;
+    chatgptAccountId?: string;
+    chatgptAccountIsFedramp: boolean;
+    expiresAt?: string;
+}
+export interface IOpenAiDeviceCode {
+    verificationUrl: string;
+    userCode: string;
+    deviceAuthId: string;
+    intervalSeconds: number;
+}
+export interface IOpenAiDeviceAuthorization {
+    authorizationCode: string;
+    codeChallenge: string;
+    codeVerifier: string;
+}
+/** The tokens one exchange or refresh produced, with the claims of the ID token (or access token). */
+export interface IOpenAiTokenSet {
+    accessToken: string;
+    refreshToken: string;
+    idToken?: string;
+    claims: IOpenAiTokenClaims;
+}
+/** Reads the account claims of a ChatGPT ID or access token. Throws `OpenAiAuthError` for anything but a JWT. */
+export declare const parseOpenAiTokenClaims: (token: string) => IOpenAiTokenClaims;
+/** Starts a device sign-in (`POST {issuer}/api/accounts/deviceauth/usercode`). */
+export declare const requestOpenAiDeviceCode: (options?: IOpenAiAuthOptions) => Promise<IOpenAiDeviceCode>;
+/** What one poll of a device sign-in found: the person has not approved it yet, or has, with its authorization. */
+export type TOpenAiDeviceCodePoll = {
+    status: 'pending';
+} | {
+    status: 'approved';
+    authorization: IOpenAiDeviceAuthorization;
+};
+/**
+ * Asks once whether the person approved the sign-in (`POST {issuer}/api/accounts/deviceauth/token`): 403 and 404
+ * mean pending, as in Codex. `timeoutMs` bounds the one request (at most thirty seconds). The authorization it
+ * answers is single-use, so one sign-in is polled by one caller at a time.
+ */
+export declare const pollOpenAiDeviceCodeOnce: (deviceCode: IOpenAiDeviceCode, options?: IOpenAiAuthOptions & {
+    timeoutMs?: number;
+}) => Promise<TOpenAiDeviceCodePoll>;
+/**
+ * Polls until the person approved the sign-in, at the interval the service asked for, and gives up after at most
+ * fifteen minutes, as Codex does.
+ */
+export declare const pollOpenAiDeviceCode: (deviceCode: IOpenAiDeviceCode, options?: IOpenAiDeviceCodePollOptions) => Promise<IOpenAiDeviceAuthorization>;
+/** Exchanges an approved device sign-in for tokens (`POST {issuer}/oauth/token`, PKCE, form-encoded). */
+export declare const exchangeOpenAiDeviceAuthorization: (authorization: IOpenAiDeviceAuthorization, options?: IOpenAiAuthOptions) => Promise<IOpenAiTokenSet>;
+/**
+ * Sends one refresh-token grant (`POST {issuer}/oauth/token`, JSON). A response without a new refresh token keeps
+ * the one that was sent, as Codex does.
+ */
+export declare const refreshOpenAiTokens: (tokens: IOpenAiTokenSet, options?: IOpenAiAuthOptions) => Promise<IOpenAiTokenSet>;
+/**
+ * Revokes a refresh token (`POST {issuer}/oauth/revoke`, JSON), as Codex does when it logs out: the grant then
+ * refreshes nothing anywhere. It resolves only once the service accepted the revocation.
+ */
+export declare const revokeOpenAiRefreshToken: (refreshToken: string, options?: IOpenAiAuthOptions) => Promise<void>;