@modelprofile.com/authswitch 9.1.0 → 10.0.0

package/dist_ts/interfaces.openai.d.ts

@@ -0,0 +1,118 @@
+/**
+ * The ChatGPT account types authswitch owns: the sign-in it runs, the credential it holds and refreshes, and the
+ * credential-free readings it takes. 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;
+}
+export interface IOpenAiProviderDescriptor {
+    providerId: 'openai';
+    displayName: string;
+    loginFlows: readonly ['device'];
+}
+/** 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 TOpenAiLoginCancelStatus = 'canceled' | 'notFound';
+/** One device sign-in in flight. `completion` settles once the person approved it, or it failed or was cancelled. */
+export interface IOpenAiLoginHandle {
+    readonly prompt: IOpenAiDevicePrompt;
+    readonly completion: Promise<IOpenAiLoginResult>;
+    cancel(): Promise<TOpenAiLoginCancelStatus>;
+    close(): Promise<void>;
+}
+export interface IOpenAiOperationOptions {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+export interface IOpenAiLoginOptions extends IOpenAiOperationOptions {
+    flow: 'device';
+}
+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;
+export interface IOpenAiRateLimitWindow {
+    usedPercent: number;
+    limitWindowSeconds: number;
+    resetAfterSeconds: number;
+    /** Unix timestamp in seconds. */
+    resetsAt: number;
+}
+export interface IOpenAiRateLimitDetails {
+    allowed: boolean;
+    limitReached: boolean;
+    primaryWindow?: IOpenAiRateLimitWindow;
+    secondaryWindow?: IOpenAiRateLimitWindow;
+}
+export interface IOpenAiAdditionalRateLimit {
+    limitName: string;
+    meteredFeature: string;
+    rateLimit?: IOpenAiRateLimitDetails;
+}
+/** An account's usage limits as `wham/usage` reports them, credential-free; the authority stores this shape. */
+export interface IOpenAiAccountRateLimits {
+    providerId: 'openai';
+    plan: string;
+    observedAt: string;
+    rateLimit?: IOpenAiRateLimitDetails;
+    additionalRateLimits: IOpenAiAdditionalRateLimit[];
+    rateLimitReachedType?: string;
+    rateLimitResetCreditsAvailableCount?: number;
+}
+export interface IOpenAiAccountRateLimitsSuccess {
+    success: true;
+    rateLimits: IOpenAiAccountRateLimits;
+}
+export interface IOpenAiAccountRateLimitsFailure {
+    success: false;
+    errorCode: TOpenAiOperationErrorCode | 'CREDENTIAL_REFRESH_REQUIRED' | 'ACCOUNT_RATE_LIMITS_FAILED';
+}
+export type TOpenAiAccountRateLimitsResult = IOpenAiAccountRateLimitsSuccess | IOpenAiAccountRateLimitsFailure;

package/dist_ts/interfaces.openai.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5vcGVuYWkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbnRlcmZhY2VzLm9wZW5haS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwySkFBMkoifQ==

package/dist_ts/openaiauth.d.ts

@@ -0,0 +1,76 @@
+import type { TOpenAiRequestOutcome } from './interfaces.openai.js';
+/**
+ * The ChatGPT sign-in protocol Codex uses (`codex-rs/login`: `device_code_auth.rs`, `auth/manager.rs`,
+ * `auth/revoke.rs`, `oauth/client.rs`), which the authority runs as the one party that signs in and refreshes:
+ * 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";
+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>;
+/**
+ * Polls until the person approved the sign-in (`POST {issuer}/api/accounts/deviceauth/token`): 403 and 404 mean
+ * pending, as in Codex, and the poll gives up after at most fifteen minutes.
+ */
+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>;

package/dist_ts/openaiauth.js

@@ -0,0 +1,371 @@
+// 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.
+/**
+ * The ChatGPT sign-in protocol Codex uses (`codex-rs/login`: `device_code_auth.rs`, `auth/manager.rs`,
+ * `auth/revoke.rs`, `oauth/client.rs`), which the authority runs as the one party that signs in and refreshes:
+ * 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 const OPENAI_AUTH_ISSUER = 'https://auth.openai.com';
+export const OPENAI_AUTH_CLIENT_ID = 'app_EMoamEEZ73f0CkXaXp7hrann';
+const DEVICE_CODE_TIMEOUT_MS = 15 * 60 * 1000;
+/** Codex's `REVOKE_HTTP_TIMEOUT`. */
+const REVOKE_TIMEOUT_MS = 10_000;
+const MAX_RESPONSE_BYTES = 64 * 1024;
+const MAX_TOKEN_BYTES = 16 * 1024;
+const MAX_AUTHORIZATION_CODE_BYTES = 8 * 1024;
+const MAX_IDENTIFIER_BYTES = 1024;
+const REQUEST_TIMEOUT_MS = 30_000;
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+const utf8ByteLength = (valueArg) => textEncoder.encode(valueArg).byteLength;
+export class OpenAiAuthError extends Error {
+    status;
+    requestOutcome;
+    retryAfterMs;
+    constructor(message, options = {}) {
+        super(message);
+        this.name = 'OpenAiAuthError';
+        this.status = options.status;
+        this.requestOutcome = options.requestOutcome;
+        this.retryAfterMs = options.retryAfterMs;
+    }
+}
+const getFetch = (options) => {
+    const fetchFunction = options.fetch ?? globalThis.fetch;
+    if (!fetchFunction)
+        throw new OpenAiAuthError('fetch is not available for OpenAI authentication.');
+    return fetchFunction;
+};
+const throwIfAborted = (options) => {
+    if (options.signal?.aborted)
+        throw new OpenAiAuthError('OpenAI authentication was aborted.');
+};
+const asString = (value, name, maximumBytes = MAX_IDENTIFIER_BYTES) => {
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new OpenAiAuthError(`OpenAI auth response is missing ${name}.`);
+    }
+    if (utf8ByteLength(value) > maximumBytes)
+        throw new OpenAiAuthError(`OpenAI auth response contains an invalid ${name}.`);
+    return value;
+};
+const asOptionalString = (value, maximumBytes = MAX_IDENTIFIER_BYTES) => {
+    if (typeof value !== 'string' || value.length === 0)
+        return undefined;
+    if (utf8ByteLength(value) > maximumBytes)
+        throw new OpenAiAuthError('OpenAI auth response contains an oversized string.');
+    return value;
+};
+/** Codex reads the interval as a string (`deserialize_interval`); both a number and a numeric string are taken. */
+const asIntervalSeconds = (value) => {
+    const interval = typeof value === 'number' ? value : Number.parseInt(String(value ?? ''), 10);
+    if (!Number.isFinite(interval) || interval <= 0 || interval > 300) {
+        throw new OpenAiAuthError('OpenAI device-code response has an invalid interval.');
+    }
+    return interval;
+};
+const readResponseText = async (response, options) => {
+    const contentLength = response.headers.get('content-length');
+    if (contentLength !== null && (!/^\d+$/.test(contentLength) || Number(contentLength) > MAX_RESPONSE_BYTES)) {
+        await response.body?.cancel().catch(() => undefined);
+        throw new OpenAiAuthError('OpenAI auth response exceeded its size limit.', { status: response.status });
+    }
+    if (!response.body)
+        return '';
+    const reader = response.body.getReader();
+    const chunks = [];
+    let byteLength = 0;
+    let completed = false;
+    const onAbort = () => { void reader.cancel().catch(() => undefined); };
+    options.signal?.addEventListener('abort', onAbort, { once: true });
+    if (options.signal?.aborted)
+        onAbort();
+    try {
+        while (true) {
+            throwIfAborted(options);
+            const { done, value } = await reader.read();
+            throwIfAborted(options);
+            if (done)
+                break;
+            byteLength += value.byteLength;
+            if (byteLength > MAX_RESPONSE_BYTES) {
+                await reader.cancel().catch(() => undefined);
+                throw new OpenAiAuthError('OpenAI auth response exceeded its size limit.', { status: response.status });
+            }
+            chunks.push(value);
+        }
+        completed = true;
+    }
+    finally {
+        options.signal?.removeEventListener('abort', onAbort);
+        if (!completed)
+            void reader.cancel().catch(() => undefined);
+        reader.releaseLock();
+    }
+    const bytes = new Uint8Array(byteLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return textDecoder.decode(bytes);
+};
+const readJson = async (response, context, options) => {
+    const body = await readResponseText(response, options);
+    if (!response.ok)
+        throw new OpenAiAuthError(`${context} failed with status ${response.status}.`, { status: response.status });
+    try {
+        return body ? JSON.parse(body) : {};
+    }
+    catch {
+        throw new OpenAiAuthError(`${context} returned invalid JSON.`, { status: response.status });
+    }
+};
+const parseRetryAfterMs = (header) => {
+    if (!header || header.length > 128)
+        return undefined;
+    const maximumDelayMs = 24 * 60 * 60 * 1000;
+    if (/^\d{1,10}$/.test(header))
+        return Math.min(Number(header) * 1000, maximumDelayMs);
+    const retryAt = Date.parse(header);
+    if (!Number.isFinite(retryAt))
+        return undefined;
+    return Math.min(Math.max(0, retryAt - Date.now()), maximumDelayMs);
+};
+/**
+ * One bounded request. Its failure says whether the request was handed to fetch at all: a refresh whose outcome
+ * is `outcomeUnknown` may have rotated the grant and is never sent again.
+ */
+const runFetch = async (url, init, options, handle, timeoutMs = REQUEST_TIMEOUT_MS) => {
+    if (options.signal?.aborted) {
+        throw new OpenAiAuthError('OpenAI authentication was aborted.', { requestOutcome: 'notSent' });
+    }
+    const controller = new AbortController();
+    let response;
+    let requestStarted = false;
+    const onExternalAbort = () => controller.abort();
+    const onRequestAbort = () => { void response?.body?.cancel().catch(() => undefined); };
+    options.signal?.addEventListener('abort', onExternalAbort, { once: true });
+    let rejectOnAbort;
+    const aborted = new Promise((_resolve, reject) => {
+        rejectOnAbort = () => reject(new Error('OpenAI authentication request aborted.'));
+        controller.signal.addEventListener('abort', rejectOnAbort, { once: true });
+    });
+    controller.signal.addEventListener('abort', onRequestAbort, { once: true });
+    if (options.signal?.aborted)
+        controller.abort();
+    const timer = setTimeout(() => controller.abort(), Math.min(timeoutMs, REQUEST_TIMEOUT_MS));
+    const requestOptions = { ...options, signal: controller.signal };
+    try {
+        return await Promise.race([
+            (async () => {
+                const fetchImplementation = getFetch(options);
+                requestStarted = true;
+                response = await fetchImplementation(url, { ...init, redirect: 'error', signal: controller.signal });
+                if (controller.signal.aborted)
+                    await response.body?.cancel().catch(() => undefined);
+                throwIfAborted(requestOptions);
+                return handle(response, requestOptions);
+            })(),
+            aborted,
+        ]);
+    }
+    catch (error) {
+        const requestOutcome = requestStarted ? 'outcomeUnknown' : 'notSent';
+        const retryAfterMs = response ? parseRetryAfterMs(response.headers.get('retry-after')) : undefined;
+        const status = error instanceof OpenAiAuthError && error.status !== undefined ? error.status : response?.status;
+        throw new OpenAiAuthError(error instanceof OpenAiAuthError ? error.message
+            : options.signal?.aborted ? 'OpenAI authentication was aborted.' : 'OpenAI authentication request failed.', {
+            requestOutcome,
+            ...(status !== undefined ? { status } : {}),
+            ...(retryAfterMs !== undefined ? { retryAfterMs } : {}),
+        });
+    }
+    finally {
+        clearTimeout(timer);
+        options.signal?.removeEventListener('abort', onExternalAbort);
+        controller.signal.removeEventListener('abort', rejectOnAbort);
+        controller.signal.removeEventListener('abort', onRequestAbort);
+    }
+};
+const postJson = (url, body, options) => runFetch(url, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) }, options, (response, requestOptions) => readJson(response, `POST ${url}`, requestOptions));
+const postForm = (url, body, options) => runFetch(url, { method: 'POST', headers: { 'Content-Type': 'application/x-www-form-urlencoded' }, body: body.toString() }, options, (response, requestOptions) => readJson(response, `POST ${url}`, requestOptions));
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+const sleepWithAbort = async (milliseconds, options) => {
+    throwIfAborted(options);
+    const signal = options.signal;
+    if (!signal) {
+        await (options.sleep ?? sleep)(milliseconds);
+        return;
+    }
+    let abortListener;
+    let timer;
+    try {
+        await Promise.race([
+            options.sleep ? options.sleep(milliseconds) : new Promise(resolve => { timer = setTimeout(resolve, milliseconds); }),
+            new Promise((_resolve, reject) => {
+                abortListener = () => reject(new OpenAiAuthError('OpenAI authentication was aborted.'));
+                signal.addEventListener('abort', abortListener, { once: true });
+                if (signal.aborted)
+                    abortListener();
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+        if (abortListener)
+            signal.removeEventListener('abort', abortListener);
+    }
+};
+const parseJwtPayload = (jwt) => {
+    const parts = jwt.split('.');
+    if (parts.length !== 3 || !parts[1])
+        throw new OpenAiAuthError('OpenAI auth returned an invalid token.');
+    try {
+        const base64 = parts[1].replace(/-/g, '+').replace(/_/g, '/');
+        const binary = atob(base64.padEnd(Math.ceil(base64.length / 4) * 4, '='));
+        const value = JSON.parse(textDecoder.decode(Uint8Array.from(binary, character => character.charCodeAt(0))));
+        if (value === null || typeof value !== 'object' || Array.isArray(value))
+            throw new Error();
+        return value;
+    }
+    catch {
+        throw new OpenAiAuthError('OpenAI token claims could not be parsed.');
+    }
+};
+const claimRecord = (value) => value !== null && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+/** Reads the account claims of a ChatGPT ID or access token. Throws `OpenAiAuthError` for anything but a JWT. */
+export const parseOpenAiTokenClaims = (token) => {
+    const claims = parseJwtPayload(token);
+    const profile = claimRecord(claims['https://api.openai.com/profile']);
+    const auth = claimRecord(claims['https://api.openai.com/auth']);
+    const expiresAtSeconds = typeof claims.exp === 'number' ? claims.exp : undefined;
+    return {
+        email: asOptionalString(claims.email) ?? asOptionalString(profile?.email),
+        chatgptPlanType: asOptionalString(auth?.chatgpt_plan_type),
+        chatgptUserId: asOptionalString(auth?.chatgpt_user_id) ?? asOptionalString(auth?.user_id),
+        chatgptAccountId: asOptionalString(auth?.chatgpt_account_id),
+        chatgptAccountIsFedramp: auth?.chatgpt_account_is_fedramp === true,
+        expiresAt: expiresAtSeconds !== undefined ? new Date(expiresAtSeconds * 1000).toISOString() : undefined,
+    };
+};
+const createTokenSet = (response, existing) => {
+    const accessToken = asOptionalString(response.access_token, MAX_TOKEN_BYTES) ?? existing?.accessToken;
+    const refreshToken = asOptionalString(response.refresh_token, MAX_TOKEN_BYTES) ?? existing?.refreshToken;
+    const idToken = asOptionalString(response.id_token, MAX_TOKEN_BYTES) ?? existing?.idToken;
+    if (!accessToken)
+        throw new OpenAiAuthError('OpenAI auth response is missing access_token.');
+    if (!refreshToken)
+        throw new OpenAiAuthError('OpenAI auth response is missing refresh_token.');
+    let claims;
+    try {
+        claims = parseOpenAiTokenClaims(idToken ?? accessToken);
+    }
+    catch {
+        throw new OpenAiAuthError('OpenAI auth returned an invalid token.');
+    }
+    return { accessToken, refreshToken, ...(idToken ? { idToken } : {}), claims };
+};
+/** Starts a device sign-in (`POST {issuer}/api/accounts/deviceauth/usercode`). */
+export const requestOpenAiDeviceCode = async (options = {}) => {
+    const response = await postJson(`${OPENAI_AUTH_ISSUER}/api/accounts/deviceauth/usercode`, { client_id: OPENAI_AUTH_CLIENT_ID }, options);
+    return {
+        verificationUrl: `${OPENAI_AUTH_ISSUER}/codex/device`,
+        userCode: asString(response.user_code ?? response.usercode, 'user_code'),
+        deviceAuthId: asString(response.device_auth_id, 'device_auth_id'),
+        intervalSeconds: asIntervalSeconds(response.interval),
+    };
+};
+/**
+ * Polls until the person approved the sign-in (`POST {issuer}/api/accounts/deviceauth/token`): 403 and 404 mean
+ * pending, as in Codex, and the poll gives up after at most fifteen minutes.
+ */
+export const pollOpenAiDeviceCode = async (deviceCode, options = {}) => {
+    const pollUrl = `${OPENAI_AUTH_ISSUER}/api/accounts/deviceauth/token`;
+    const timeoutMs = options.timeoutMs ?? DEVICE_CODE_TIMEOUT_MS;
+    if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > DEVICE_CODE_TIMEOUT_MS) {
+        throw new OpenAiAuthError('OpenAI device-code timeout is invalid.');
+    }
+    if (utf8ByteLength(deviceCode.deviceAuthId) > MAX_IDENTIFIER_BYTES
+        || utf8ByteLength(deviceCode.userCode) > MAX_IDENTIFIER_BYTES
+        || !Number.isSafeInteger(deviceCode.intervalSeconds) || deviceCode.intervalSeconds < 1
+        || deviceCode.intervalSeconds > 300) {
+        throw new OpenAiAuthError('OpenAI device-code input is invalid.');
+    }
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < timeoutMs) {
+        const remainingBeforeRequest = timeoutMs - (Date.now() - startedAt);
+        const pollResult = await runFetch(pollUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ device_auth_id: deviceCode.deviceAuthId, user_code: deviceCode.userCode }),
+        }, options, async (response, requestOptions) => {
+            if (response.ok) {
+                return { status: 'complete',
+                    body: await readJson(response, `POST ${pollUrl}`, requestOptions) };
+            }
+            await readResponseText(response, requestOptions);
+            if (response.status !== 403 && response.status !== 404) {
+                throw new OpenAiAuthError(`OpenAI device-code polling failed with status ${response.status}.`, { status: response.status });
+            }
+            return { status: 'pending' };
+        }, Math.max(remainingBeforeRequest, 1));
+        if (pollResult.status === 'complete') {
+            return {
+                authorizationCode: asString(pollResult.body.authorization_code, 'authorization_code', MAX_AUTHORIZATION_CODE_BYTES),
+                codeChallenge: asString(pollResult.body.code_challenge, 'code_challenge'),
+                codeVerifier: asString(pollResult.body.code_verifier, 'code_verifier'),
+            };
+        }
+        const remaining = timeoutMs - (Date.now() - startedAt);
+        await sleepWithAbort(Math.min(deviceCode.intervalSeconds * 1000, Math.max(remaining, 0)), options);
+    }
+    throw new OpenAiAuthError('OpenAI device-code login timed out.');
+};
+/** Exchanges an approved device sign-in for tokens (`POST {issuer}/oauth/token`, PKCE, form-encoded). */
+export const exchangeOpenAiDeviceAuthorization = async (authorization, options = {}) => {
+    const response = await postForm(`${OPENAI_AUTH_ISSUER}/oauth/token`, new URLSearchParams({
+        grant_type: 'authorization_code',
+        code: authorization.authorizationCode,
+        redirect_uri: `${OPENAI_AUTH_ISSUER}/deviceauth/callback`,
+        client_id: OPENAI_AUTH_CLIENT_ID,
+        code_verifier: authorization.codeVerifier,
+    }), options);
+    return createTokenSet(response);
+};
+/**
+ * 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 const refreshOpenAiTokens = async (tokens, options = {}) => {
+    const response = await postJson(`${OPENAI_AUTH_ISSUER}/oauth/token`, {
+        client_id: OPENAI_AUTH_CLIENT_ID,
+        grant_type: 'refresh_token',
+        refresh_token: tokens.refreshToken,
+    }, options);
+    return createTokenSet({
+        id_token: response.id_token ?? tokens.idToken,
+        access_token: response.access_token ?? tokens.accessToken,
+        refresh_token: response.refresh_token ?? tokens.refreshToken,
+    }, tokens);
+};
+/**
+ * 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 const revokeOpenAiRefreshToken = async (refreshToken, options = {}) => {
+    if (typeof refreshToken !== 'string' || !refreshToken || utf8ByteLength(refreshToken) > MAX_TOKEN_BYTES) {
+        throw new OpenAiAuthError('OpenAI revocation input is invalid.', { requestOutcome: 'notSent' });
+    }
+    const url = `${OPENAI_AUTH_ISSUER}/oauth/revoke`;
+    await runFetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ token: refreshToken, token_type_hint: 'refresh_token', client_id: OPENAI_AUTH_CLIENT_ID }),
+    }, options, async (response, requestOptions) => {
+        await readResponseText(response, requestOptions);
+        if (!response.ok)
+            throw new OpenAiAuthError(`POST ${url} failed with status ${response.status}.`, { status: response.status });
+    }, REVOKE_TIMEOUT_MS);
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"openaiauth.js","sourceRoot":"","sources":["../ts/openaiauth.ts"],"names":[],"mappings":"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"}