@modelprofile.com/flexharness-providers 7.0.0

package/dist_ts_openai_account/smartai.providers.openai.js

@@ -0,0 +1,1075 @@
+// OpenAI protocol portions are adapted in TypeScript; see third-party-notices.md.
+import * as plugins from './plugins.js';
+import { OPENAI_CHATGPT_CODEX_BASE_URL, OPENAI_CHATGPT_DEFAULT_ORIGINATOR, completeOpenAiChatGptDeviceCodeLogin, createOpenAiChatGptBrowserAuthorization, exchangeOpenAiChatGptBrowserAuthorizationCode, parseOpenAiChatGptBrowserCallback, parseOpenAiChatGptTokenInfo, refreshOpenAiChatGptTokenData, requestOpenAiChatGptDeviceCode, revokeOpenAiChatGptToken, } from '@modelprofile.com/flexharness-providers/auth';
+import { createSmartAiProviderError, SmartAiProviderError } from './smartai.providers.error.js';
+const defaultBrowserLoginTimeoutMs = 11 * 60 * 1000;
+const defaultDeviceLoginTimeoutMs = 15 * 60 * 1000;
+const defaultOperationTimeoutMs = 30_000;
+const maximumOperationTimeoutMs = 20 * 60 * 1000;
+const maximumCatalogBytes = 2 * 1024 * 1024;
+const maximumAccountRateLimitsBytes = 256 * 1024;
+const maximumCatalogModels = 256;
+const maximumAdditionalRateLimits = 128;
+const maximumCursorBytes = 4096;
+const maximumModelPageSize = 50;
+const defaultClientVersion = '0.146.1';
+const maximumHeaderBytes = 16 * 1024;
+const maximumCallbackUrlBytes = 4096;
+const accountRateLimitsUrl = 'https://chatgpt.com/backend-api/wham/usage';
+class ModelHttpError extends Error {
+    status;
+    constructor(status) {
+        super('Model catalog request failed.');
+        this.status = status;
+    }
+}
+class AccountRateLimitsHttpError extends Error {
+    status;
+    constructor(status) {
+        super('Account rate-limits request failed.');
+        this.status = status;
+    }
+}
+const isRecord = (valueArg) => typeof valueArg === 'object' && valueArg !== null && !Array.isArray(valueArg);
+const boundedString = (valueArg, maximumBytesArg, allowEmptyArg = false) => {
+    if (typeof valueArg !== 'string'
+        || (!allowEmptyArg && valueArg.length === 0)
+        || plugins.Buffer.byteLength(valueArg, 'utf8') > maximumBytesArg) {
+        throw createSmartAiProviderError('PROTOCOL_ERROR');
+    }
+    return valueArg;
+};
+const createOperation = (optionsArg, defaultTimeoutMsArg) => {
+    const timeoutMs = optionsArg.timeoutMs ?? defaultTimeoutMsArg;
+    if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > maximumOperationTimeoutMs) {
+        throw createSmartAiProviderError('INVALID_ARGUMENT');
+    }
+    const controller = new AbortController();
+    let timedOut = false;
+    const onExternalAbort = () => controller.abort();
+    optionsArg.signal?.addEventListener('abort', onExternalAbort, { once: true });
+    if (optionsArg.signal?.aborted)
+        controller.abort();
+    const timer = setTimeout(() => {
+        timedOut = true;
+        controller.abort();
+    }, timeoutMs);
+    return {
+        controller,
+        signal: controller.signal,
+        get timedOut() {
+            return timedOut;
+        },
+        cleanup: () => {
+            clearTimeout(timer);
+            optionsArg.signal?.removeEventListener('abort', onExternalAbort);
+        },
+    };
+};
+const classifyOperationError = (errorArg, operationArg, fallbackArg) => {
+    if (operationArg.timedOut)
+        return 'TIMEOUT';
+    if (operationArg.signal.aborted)
+        return 'ABORTED';
+    if (errorArg instanceof SmartAiProviderError && errorArg.code === 'ABORTED')
+        return 'ABORTED';
+    if (errorArg instanceof SmartAiProviderError && errorArg.code === 'TIMEOUT')
+        return 'TIMEOUT';
+    return fallbackArg;
+};
+const toTokenData = (credentialArg) => {
+    if (credentialArg.kind !== 'chatgptOAuth'
+        || credentialArg.providerId !== 'openai'
+        || !credentialArg.accessToken
+        || !credentialArg.refreshToken
+        || !credentialArg.idToken) {
+        throw createSmartAiProviderError('CREDENTIAL_INVALID');
+    }
+    let tokenInfo;
+    try {
+        tokenInfo = parseOpenAiChatGptTokenInfo(credentialArg.idToken);
+    }
+    catch {
+        throw createSmartAiProviderError('CREDENTIAL_INVALID');
+    }
+    return {
+        accessToken: credentialArg.accessToken,
+        refreshToken: credentialArg.refreshToken,
+        idToken: credentialArg.idToken,
+        accountId: tokenInfo.chatgptAccountId,
+        tokenInfo,
+    };
+};
+const toCredential = (tokenDataArg, lastRefreshAtArg) => {
+    if (!tokenDataArg.idToken)
+        throw createSmartAiProviderError('CREDENTIAL_INVALID');
+    return {
+        kind: 'chatgptOAuth',
+        providerId: 'openai',
+        accessToken: tokenDataArg.accessToken,
+        refreshToken: tokenDataArg.refreshToken,
+        idToken: tokenDataArg.idToken,
+        ...(lastRefreshAtArg === undefined ? {} : { lastRefreshAt: lastRefreshAtArg }),
+    };
+};
+const toSummary = (credentialArg) => {
+    const tokenData = toTokenData(credentialArg);
+    return {
+        providerId: 'openai',
+        authKind: 'chatgptOAuth',
+        ...(tokenData.tokenInfo.chatgptAccountId
+            ? { accountId: tokenData.tokenInfo.chatgptAccountId }
+            : {}),
+        ...(tokenData.tokenInfo.email ? { email: tokenData.tokenInfo.email } : {}),
+        ...(tokenData.tokenInfo.chatgptPlanType ? { plan: tokenData.tokenInfo.chatgptPlanType } : {}),
+    };
+};
+const closeServer = async (serverArg, socketsArg) => {
+    await new Promise((resolve, reject) => {
+        if (!serverArg.listening) {
+            resolve();
+            return;
+        }
+        serverArg.close((errorArg) => {
+            if (errorArg?.code === 'ERR_SERVER_NOT_RUNNING') {
+                resolve();
+            }
+            else if (errorArg) {
+                reject(errorArg);
+            }
+            else {
+                resolve();
+            }
+        });
+        for (const socket of socketsArg)
+            socket.destroy();
+    });
+};
+const bindBrowserCallbackServer = async (portsArg, signalArg) => {
+    if (portsArg.length === 0
+        || portsArg.some((port) => !Number.isSafeInteger(port) || port < 1 || port > 65535)) {
+        throw createSmartAiProviderError('INVALID_ARGUMENT');
+    }
+    let lastError;
+    for (let index = 0; index < portsArg.length; index++) {
+        const port = portsArg[index];
+        const sockets = new Set();
+        let authorization;
+        let settled = false;
+        let resolveCallback;
+        let rejectCallback;
+        const callback = new Promise((resolve, reject) => {
+            resolveCallback = resolve;
+            rejectCallback = reject;
+        });
+        void callback.catch(() => undefined);
+        const server = plugins.http.createServer({ maxHeaderSize: maximumHeaderBytes }, (request, response) => {
+            const rejectRequest = (status) => {
+                response.writeHead(status, {
+                    'Content-Type': 'text/plain; charset=utf-8',
+                    'Cache-Control': 'no-store',
+                    'X-Content-Type-Options': 'nosniff',
+                });
+                response.end('OpenAI login callback rejected.');
+            };
+            const host = request.headers.host;
+            const requestUrl = request.url;
+            const headerBytes = request.rawHeaders.reduce((total, entry) => total + plugins.Buffer.byteLength(entry, 'utf8'), 0);
+            if (settled
+                || !authorization
+                || request.method !== 'GET'
+                || host !== `localhost:${port}`
+                || typeof requestUrl !== 'string'
+                || plugins.Buffer.byteLength(requestUrl, 'utf8') > maximumCallbackUrlBytes
+                || headerBytes > maximumHeaderBytes) {
+                rejectRequest(settled ? 410 : 400);
+                return;
+            }
+            const callbackUrl = `http://${host}${requestUrl}`;
+            let providerDenied = false;
+            try {
+                const callback = parseOpenAiChatGptBrowserCallback(callbackUrl, {
+                    expectedState: authorization.state,
+                    expectedRedirectUri: authorization.redirectUri,
+                });
+                providerDenied = 'providerError' in callback;
+            }
+            catch {
+                rejectRequest(400);
+                return;
+            }
+            settled = true;
+            response.writeHead(200, {
+                'Content-Type': 'text/plain; charset=utf-8',
+                'Cache-Control': 'no-store',
+                'X-Content-Type-Options': 'nosniff',
+            });
+            response.end(providerDenied
+                ? 'OpenAI login was not authorized. You may close this window.'
+                : 'OpenAI login completed. You may close this window.');
+            resolveCallback(callbackUrl);
+        });
+        server.on('connection', (socket) => {
+            sockets.add(socket);
+            socket.once('close', () => sockets.delete(socket));
+        });
+        let serverClosePromise;
+        const ensureServerClosed = () => {
+            if (!serverClosePromise) {
+                serverClosePromise = closeServer(server, sockets).finally(() => {
+                    serverClosePromise = undefined;
+                });
+            }
+            return serverClosePromise;
+        };
+        const onAbort = () => {
+            if (!settled) {
+                settled = true;
+                rejectCallback(createSmartAiProviderError('ABORTED'));
+            }
+            void ensureServerClosed().catch(() => undefined);
+        };
+        signalArg.addEventListener('abort', onAbort, { once: true });
+        try {
+            await new Promise((resolve, reject) => {
+                const onError = (errorArg) => {
+                    server.removeListener('listening', onListening);
+                    reject(errorArg);
+                };
+                const onListening = () => {
+                    server.removeListener('error', onError);
+                    resolve();
+                };
+                server.once('error', onError);
+                server.once('listening', onListening);
+                server.listen(port, '127.0.0.1');
+            });
+            if (signalArg.aborted)
+                onAbort();
+            return {
+                port,
+                waitForCallback: async (authorizationArg) => {
+                    authorization = authorizationArg;
+                    return callback;
+                },
+                close: async () => {
+                    signalArg.removeEventListener('abort', onAbort);
+                    if (!settled) {
+                        settled = true;
+                        rejectCallback(createSmartAiProviderError('LOGIN_CANCELED'));
+                    }
+                    await ensureServerClosed();
+                },
+            };
+        }
+        catch (errorArg) {
+            signalArg.removeEventListener('abort', onAbort);
+            await ensureServerClosed().catch(() => undefined);
+            lastError = errorArg;
+            const code = errorArg.code;
+            if (code !== 'EADDRINUSE' || index === portsArg.length - 1)
+                break;
+        }
+    }
+    throw createSmartAiProviderError(lastError?.code === 'EADDRINUSE'
+        ? 'LOGIN_BUSY'
+        : 'LOGIN_FAILED');
+};
+class OpenAiProviderLoginHandle {
+    prompt;
+    abortController;
+    cleanup;
+    onDone;
+    completion;
+    closePromise;
+    done = false;
+    constructor(prompt, completionArg, abortController, cleanup, onDone) {
+        this.prompt = prompt;
+        this.abortController = abortController;
+        this.cleanup = cleanup;
+        this.onDone = onDone;
+        this.completion = completionArg.finally(async () => {
+            this.done = true;
+            try {
+                await this.cleanup();
+            }
+            finally {
+                this.onDone();
+            }
+        });
+        void this.completion.catch(() => undefined);
+    }
+    async cancel() {
+        if (this.done || this.abortController.signal.aborted)
+            return 'notFound';
+        this.abortController.abort();
+        return 'canceled';
+    }
+    async close() {
+        if (this.closePromise)
+            return this.closePromise;
+        const closeAttempt = (async () => {
+            await this.cancel();
+            await this.completion.catch(() => undefined);
+            await this.cleanup();
+        })();
+        this.closePromise = closeAttempt;
+        try {
+            await closeAttempt;
+        }
+        catch (error) {
+            this.closePromise = undefined;
+            throw error;
+        }
+    }
+}
+const normalizeModelListOptions = (optionsArg) => {
+    const limit = optionsArg.limit ?? maximumModelPageSize;
+    if (!Number.isSafeInteger(limit)
+        || limit < 1
+        || limit > maximumModelPageSize
+        || (optionsArg.cursor !== undefined
+            && (optionsArg.cursor.length === 0
+                || plugins.Buffer.byteLength(optionsArg.cursor, 'utf8') > maximumCursorBytes))
+        || (optionsArg.includeHidden !== undefined && typeof optionsArg.includeHidden !== 'boolean')) {
+        throw createSmartAiProviderError('INVALID_ARGUMENT');
+    }
+    return { ...optionsArg, limit, includeHidden: optionsArg.includeHidden ?? false };
+};
+const readBoundedJson = async (responseArg, signalArg, maximumBytesArg) => {
+    const declared = responseArg.headers.get('content-length');
+    if (declared !== null && (!/^\d+$/.test(declared) || Number(declared) > maximumBytesArg)) {
+        await responseArg.body?.cancel().catch(() => undefined);
+        throw createSmartAiProviderError('PROTOCOL_ERROR');
+    }
+    if (!responseArg.body)
+        throw createSmartAiProviderError('PROTOCOL_ERROR');
+    const reader = responseArg.body.getReader();
+    const chunks = [];
+    let size = 0;
+    let completed = false;
+    const onAbort = () => {
+        void reader.cancel().catch(() => undefined);
+    };
+    signalArg.addEventListener('abort', onAbort, { once: true });
+    if (signalArg.aborted)
+        onAbort();
+    try {
+        while (true) {
+            if (signalArg.aborted)
+                throw createSmartAiProviderError('ABORTED');
+            const { done, value } = await reader.read();
+            if (signalArg.aborted)
+                throw createSmartAiProviderError('ABORTED');
+            if (done)
+                break;
+            size += value.byteLength;
+            if (size > maximumBytesArg) {
+                await reader.cancel().catch(() => undefined);
+                throw createSmartAiProviderError('PROTOCOL_ERROR');
+            }
+            chunks.push(value);
+        }
+        completed = true;
+    }
+    finally {
+        signalArg.removeEventListener('abort', onAbort);
+        if (!completed)
+            void reader.cancel().catch(() => undefined);
+        reader.releaseLock();
+    }
+    const body = plugins.Buffer.allocUnsafe(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+        body.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    try {
+        return JSON.parse(body.toString('utf8'));
+    }
+    catch {
+        throw createSmartAiProviderError('PROTOCOL_ERROR');
+    }
+};
+const boundedInteger = (valueArg, minimumArg, maximumArg = Number.MAX_SAFE_INTEGER) => {
+    if (!Number.isSafeInteger(valueArg)
+        || valueArg < minimumArg
+        || valueArg > maximumArg) {
+        throw createSmartAiProviderError('PROTOCOL_ERROR');
+    }
+    return valueArg;
+};
+const projectRateLimitWindow = (valueArg) => {
+    if (!isRecord(valueArg))
+        throw createSmartAiProviderError('PROTOCOL_ERROR');
+    return {
+        usedPercent: boundedInteger(valueArg.used_percent, 0, 100),
+        limitWindowSeconds: boundedInteger(valueArg.limit_window_seconds, 1),
+        resetAfterSeconds: boundedInteger(valueArg.reset_after_seconds, 0),
+        resetsAt: boundedInteger(valueArg.reset_at, 0),
+    };
+};
+const projectRateLimitDetails = (valueArg) => {
+    if (!isRecord(valueArg)
+        || typeof valueArg.allowed !== 'boolean'
+        || typeof valueArg.limit_reached !== 'boolean') {
+        throw createSmartAiProviderError('PROTOCOL_ERROR');
+    }
+    return {
+        allowed: valueArg.allowed,
+        limitReached: valueArg.limit_reached,
+        ...(valueArg.primary_window === null || valueArg.primary_window === undefined
+            ? {}
+            : { primaryWindow: projectRateLimitWindow(valueArg.primary_window) }),
+        ...(valueArg.secondary_window === null || valueArg.secondary_window === undefined
+            ? {}
+            : { secondaryWindow: projectRateLimitWindow(valueArg.secondary_window) }),
+    };
+};
+const projectAccountRateLimits = (valueArg, observedAtArg) => {
+    if (!isRecord(valueArg))
+        throw createSmartAiProviderError('PROTOCOL_ERROR');
+    const rawAdditionalRateLimits = valueArg.additional_rate_limits ?? [];
+    if (!Array.isArray(rawAdditionalRateLimits)
+        || rawAdditionalRateLimits.length > maximumAdditionalRateLimits) {
+        throw createSmartAiProviderError('PROTOCOL_ERROR');
+    }
+    const additionalRateLimits = rawAdditionalRateLimits.map((rawLimit) => {
+        if (!isRecord(rawLimit))
+            throw createSmartAiProviderError('PROTOCOL_ERROR');
+        return {
+            limitName: boundedString(rawLimit.limit_name, 256),
+            meteredFeature: boundedString(rawLimit.metered_feature, 256),
+            ...(rawLimit.rate_limit === null || rawLimit.rate_limit === undefined
+                ? {}
+                : { rateLimit: projectRateLimitDetails(rawLimit.rate_limit) }),
+        };
+    });
+    let rateLimitReachedType;
+    if (valueArg.rate_limit_reached_type !== null && valueArg.rate_limit_reached_type !== undefined) {
+        if (!isRecord(valueArg.rate_limit_reached_type)) {
+            throw createSmartAiProviderError('PROTOCOL_ERROR');
+        }
+        rateLimitReachedType = boundedString(valueArg.rate_limit_reached_type.type, 256);
+    }
+    let rateLimitResetCreditsAvailableCount;
+    if (valueArg.rate_limit_reset_credits !== null && valueArg.rate_limit_reset_credits !== undefined) {
+        if (!isRecord(valueArg.rate_limit_reset_credits)) {
+            throw createSmartAiProviderError('PROTOCOL_ERROR');
+        }
+        rateLimitResetCreditsAvailableCount = boundedInteger(valueArg.rate_limit_reset_credits.available_count, 0);
+    }
+    return {
+        providerId: 'openai',
+        plan: boundedString(valueArg.plan_type, 256),
+        observedAt: observedAtArg,
+        ...(valueArg.rate_limit === null || valueArg.rate_limit === undefined
+            ? {}
+            : { rateLimit: projectRateLimitDetails(valueArg.rate_limit) }),
+        additionalRateLimits,
+        ...(rateLimitReachedType === undefined ? {} : { rateLimitReachedType }),
+        ...(rateLimitResetCreditsAvailableCount === undefined
+            ? {}
+            : { rateLimitResetCreditsAvailableCount }),
+    };
+};
+const projectCatalog = (valueArg) => {
+    if (!isRecord(valueArg) || !Array.isArray(valueArg.models) || valueArg.models.length > maximumCatalogModels) {
+        throw createSmartAiProviderError('PROTOCOL_ERROR');
+    }
+    const modelIds = new Set();
+    const entries = valueArg.models.map((rawModel, sourceIndex) => {
+        if (!isRecord(rawModel))
+            throw createSmartAiProviderError('PROTOCOL_ERROR');
+        const modelId = boundedString(rawModel.slug, 256);
+        if (modelIds.has(modelId))
+            throw createSmartAiProviderError('PROTOCOL_ERROR');
+        modelIds.add(modelId);
+        const visibility = rawModel.visibility;
+        if (visibility !== 'list' && visibility !== 'hide' && visibility !== 'none') {
+            throw createSmartAiProviderError('PROTOCOL_ERROR');
+        }
+        if (!Number.isSafeInteger(rawModel.priority))
+            throw createSmartAiProviderError('PROTOCOL_ERROR');
+        if (!Array.isArray(rawModel.supported_reasoning_levels) || rawModel.supported_reasoning_levels.length > 16) {
+            throw createSmartAiProviderError('PROTOCOL_ERROR');
+        }
+        const reasoningEfforts = rawModel.supported_reasoning_levels.map((rawEffort) => {
+            if (!isRecord(rawEffort))
+                throw createSmartAiProviderError('PROTOCOL_ERROR');
+            return {
+                effort: boundedString(rawEffort.effort, 128),
+                description: boundedString(rawEffort.description, 1024, true),
+            };
+        });
+        const modalities = rawModel.input_modalities ?? ['text', 'image'];
+        if (!Array.isArray(modalities)
+            || modalities.length > 3
+            || modalities.some((entry) => entry !== 'text' && entry !== 'image' && entry !== 'audio')
+            || new Set(modalities).size !== modalities.length) {
+            throw createSmartAiProviderError('PROTOCOL_ERROR');
+        }
+        const rawServiceTiers = rawModel.service_tiers ?? [];
+        if (!Array.isArray(rawServiceTiers) || rawServiceTiers.length > 16) {
+            throw createSmartAiProviderError('PROTOCOL_ERROR');
+        }
+        const serviceTiers = rawServiceTiers.map((rawTier) => {
+            if (!isRecord(rawTier))
+                throw createSmartAiProviderError('PROTOCOL_ERROR');
+            return {
+                id: boundedString(rawTier.id, 128),
+                name: boundedString(rawTier.name, 256),
+                description: boundedString(rawTier.description, 1024, true),
+            };
+        });
+        const modelMessages = isRecord(rawModel.model_messages) ? rawModel.model_messages : undefined;
+        const variables = isRecord(modelMessages?.instructions_variables)
+            ? modelMessages.instructions_variables
+            : undefined;
+        const supportsPersonality = typeof modelMessages?.instructions_template === 'string'
+            && modelMessages.instructions_template.includes('{{ personality }}')
+            && typeof variables?.personality_default === 'string'
+            && typeof variables.personality_friendly === 'string'
+            && typeof variables.personality_pragmatic === 'string';
+        return {
+            priority: rawModel.priority,
+            sourceIndex,
+            model: {
+                providerId: 'openai',
+                modelId,
+                wireModel: modelId,
+                displayName: boundedString(rawModel.display_name, 512),
+                description: rawModel.description === null || rawModel.description === undefined
+                    ? ''
+                    : boundedString(rawModel.description, 4096, true),
+                hidden: visibility !== 'list',
+                reasoningEfforts,
+                defaultReasoningEffort: rawModel.default_reasoning_level === null
+                    || rawModel.default_reasoning_level === undefined
+                    ? 'none'
+                    : boundedString(rawModel.default_reasoning_level, 128),
+                inputModalities: modalities,
+                supportsPersonality,
+                serviceTiers,
+                ...(rawModel.default_service_tier === null || rawModel.default_service_tier === undefined
+                    ? {}
+                    : { defaultServiceTier: boundedString(rawModel.default_service_tier, 128) }),
+                isDefault: false,
+            },
+        };
+    });
+    entries.sort((left, right) => left.priority - right.priority || left.sourceIndex - right.sourceIndex);
+    const models = entries.map((entry) => entry.model);
+    const defaultModel = models.find((model) => !model.hidden) ?? models[0];
+    if (defaultModel)
+        defaultModel.isDefault = true;
+    return models;
+};
+export class OpenAiProviderAdapter {
+    descriptor = {
+        providerId: 'openai',
+        displayName: 'OpenAI',
+        loginFlows: ['browser', 'device'],
+        supportsApiKey: true,
+    };
+    fetchImplementation;
+    originator;
+    now;
+    cursorKey = plugins.crypto.randomBytes(32);
+    handles = new Set();
+    operations = new Set();
+    refreshes = new Map();
+    closed = false;
+    disposePromise;
+    constructor(optionsArg = {}) {
+        this.fetchImplementation = optionsArg.fetch ?? globalThis.fetch;
+        if (!this.fetchImplementation)
+            throw createSmartAiProviderError('INVALID_ARGUMENT');
+        this.originator = optionsArg.originator ?? OPENAI_CHATGPT_DEFAULT_ORIGINATOR;
+        this.now = optionsArg.now ?? (() => new Date());
+    }
+    requireOpen() {
+        if (this.closed)
+            throw createSmartAiProviderError('CLOSED');
+    }
+    authOptions(signalArg) {
+        return {
+            fetch: this.fetchImplementation,
+            signal: signalArg,
+            safeErrors: true,
+        };
+    }
+    createApiKeyCredential(apiKeyArg) {
+        this.requireOpen();
+        if (typeof apiKeyArg !== 'string' || apiKeyArg.length === 0) {
+            throw createSmartAiProviderError('INVALID_ARGUMENT');
+        }
+        return { kind: 'apiKey', providerId: 'openai', apiKey: apiKeyArg };
+    }
+    inspectCredential(credentialArg) {
+        this.requireOpen();
+        if (credentialArg.kind === 'apiKey') {
+            if (credentialArg.providerId !== 'openai' || !credentialArg.apiKey) {
+                throw createSmartAiProviderError('CREDENTIAL_INVALID');
+            }
+            return { providerId: 'openai', authKind: 'apiKey' };
+        }
+        return toSummary(credentialArg);
+    }
+    async beginLogin(optionsArg) {
+        this.requireOpen();
+        if (optionsArg.flow !== 'browser' && optionsArg.flow !== 'device') {
+            throw createSmartAiProviderError('INVALID_ARGUMENT');
+        }
+        const defaultTimeoutMs = optionsArg.flow === 'browser'
+            ? defaultBrowserLoginTimeoutMs
+            : defaultDeviceLoginTimeoutMs;
+        if (optionsArg.flow === 'device'
+            && (optionsArg.timeoutMs ?? defaultTimeoutMs) > defaultDeviceLoginTimeoutMs) {
+            throw createSmartAiProviderError('INVALID_ARGUMENT');
+        }
+        const operation = createOperation(optionsArg, defaultTimeoutMs);
+        const abortController = operation.controller;
+        this.operations.add(abortController);
+        const timeoutMs = optionsArg.timeoutMs ?? defaultTimeoutMs;
+        let callbackServer;
+        const cleanup = async () => {
+            this.operations.delete(abortController);
+            operation.cleanup();
+            await callbackServer?.close();
+        };
+        try {
+            let prompt;
+            let completion;
+            if (optionsArg.flow === 'device') {
+                const deviceCode = await requestOpenAiChatGptDeviceCode(this.authOptions(abortController.signal));
+                prompt = {
+                    flow: 'device',
+                    verificationUrl: deviceCode.verificationUrl,
+                    userCode: deviceCode.userCode,
+                };
+                completion = completeOpenAiChatGptDeviceCodeLogin(deviceCode, {
+                    ...this.authOptions(abortController.signal),
+                    timeoutMs,
+                }).then((tokenData) => {
+                    const credential = toCredential(tokenData);
+                    return { credential, account: toSummary(credential) };
+                });
+            }
+            else {
+                callbackServer = await bindBrowserCallbackServer([1455, 1457], abortController.signal);
+                const authorization = await createOpenAiChatGptBrowserAuthorization({
+                    ...this.authOptions(abortController.signal),
+                    redirectUri: `http://localhost:${callbackServer.port}/auth/callback`,
+                    originator: this.originator,
+                });
+                prompt = { flow: 'browser', authUrl: authorization.authUrl };
+                completion = callbackServer.waitForCallback(authorization).then(async (callbackUrl) => {
+                    const callback = parseOpenAiChatGptBrowserCallback(callbackUrl, {
+                        expectedState: authorization.state,
+                        expectedRedirectUri: authorization.redirectUri,
+                    });
+                    if ('providerError' in callback) {
+                        throw createSmartAiProviderError('LOGIN_CANCELED');
+                    }
+                    const tokenData = await exchangeOpenAiChatGptBrowserAuthorizationCode(callback.authorizationCode, {
+                        ...this.authOptions(abortController.signal),
+                        redirectUri: authorization.redirectUri,
+                        codeVerifier: authorization.codeVerifier,
+                    });
+                    const credential = toCredential(tokenData);
+                    return { credential, account: toSummary(credential) };
+                });
+            }
+            this.requireOpen();
+            if (abortController.signal.aborted)
+                throw createSmartAiProviderError('ABORTED');
+            const handle = new OpenAiProviderLoginHandle(prompt, completion.catch((errorArg) => {
+                if (operation.timedOut)
+                    throw createSmartAiProviderError('TIMEOUT');
+                if (optionsArg.signal?.aborted)
+                    throw createSmartAiProviderError('ABORTED');
+                if (abortController.signal.aborted)
+                    throw createSmartAiProviderError('LOGIN_CANCELED');
+                if (errorArg instanceof SmartAiProviderError)
+                    throw errorArg;
+                throw createSmartAiProviderError('LOGIN_FAILED');
+            }), abortController, cleanup, () => this.handles.delete(handle));
+            this.handles.add(handle);
+            return handle;
+        }
+        catch (errorArg) {
+            abortController.abort();
+            await cleanup().catch(() => undefined);
+            if (operation.timedOut)
+                throw createSmartAiProviderError('TIMEOUT');
+            if (optionsArg.signal?.aborted)
+                throw createSmartAiProviderError('ABORTED');
+            if (errorArg instanceof SmartAiProviderError)
+                throw errorArg;
+            throw createSmartAiProviderError('LOGIN_FAILED');
+        }
+    }
+    async refreshCredential(credentialArg, optionsArg = {}) {
+        this.requireOpen();
+        toTokenData(credentialArg);
+        const waitOperation = createOperation(optionsArg, defaultOperationTimeoutMs);
+        if (waitOperation.signal.aborted) {
+            const failure = {
+                success: false,
+                credential: credentialArg,
+                errorCode: waitOperation.timedOut ? 'TIMEOUT' : 'ABORTED',
+            };
+            waitOperation.cleanup();
+            return failure;
+        }
+        let sharedRefresh;
+        let joinedRefresh = false;
+        let onAbort;
+        try {
+            const refreshKey = plugins.crypto.createHash('sha256')
+                .update(credentialArg.refreshToken, 'utf8')
+                .digest('base64url');
+            sharedRefresh = this.refreshes.get(refreshKey);
+            if (!sharedRefresh) {
+                const controller = new AbortController();
+                let createdRefresh;
+                const promise = this.performRefreshCredential(credentialArg, {
+                    signal: controller.signal,
+                }).finally(() => {
+                    createdRefresh.settled = true;
+                    if (this.refreshes.get(refreshKey) === createdRefresh) {
+                        this.refreshes.delete(refreshKey);
+                    }
+                });
+                createdRefresh = {
+                    controller,
+                    promise,
+                    waiters: 0,
+                    settled: false,
+                };
+                this.refreshes.set(refreshKey, createdRefresh);
+                sharedRefresh = createdRefresh;
+            }
+            sharedRefresh.waiters++;
+            joinedRefresh = true;
+            const aborted = new Promise((resolve) => {
+                onAbort = () => resolve({
+                    success: false,
+                    credential: credentialArg,
+                    errorCode: waitOperation.timedOut ? 'TIMEOUT' : 'ABORTED',
+                });
+                waitOperation.signal.addEventListener('abort', onAbort, { once: true });
+            });
+            return await Promise.race([sharedRefresh.promise, aborted]);
+        }
+        finally {
+            if (onAbort)
+                waitOperation.signal.removeEventListener('abort', onAbort);
+            waitOperation.cleanup();
+            if (sharedRefresh && joinedRefresh)
+                sharedRefresh.waiters--;
+            if (sharedRefresh && joinedRefresh && sharedRefresh.waiters === 0 && !sharedRefresh.settled) {
+                sharedRefresh.controller.abort();
+            }
+        }
+    }
+    async performRefreshCredential(credentialArg, optionsArg) {
+        const input = toTokenData(credentialArg);
+        const operation = createOperation(optionsArg, defaultOperationTimeoutMs);
+        this.operations.add(operation.controller);
+        try {
+            const refreshed = await refreshOpenAiChatGptTokenData(input, this.authOptions(operation.signal));
+            const tokenChanged = refreshed.accessToken !== input.accessToken
+                || refreshed.refreshToken !== input.refreshToken;
+            if (!tokenChanged || !refreshed.idToken) {
+                return { success: false, credential: credentialArg, errorCode: 'REFRESH_FAILED' };
+            }
+            const previous = credentialArg.lastRefreshAt === undefined
+                ? 0
+                : Date.parse(credentialArg.lastRefreshAt);
+            const now = this.now().getTime();
+            const lastRefreshAt = new Date(Math.max(now, Number.isFinite(previous) ? previous + 1 : now))
+                .toISOString();
+            const credential = toCredential(refreshed, lastRefreshAt);
+            return { success: true, credential, account: toSummary(credential) };
+        }
+        catch (errorArg) {
+            return {
+                success: false,
+                credential: credentialArg,
+                errorCode: classifyOperationError(errorArg, operation, 'REFRESH_FAILED'),
+            };
+        }
+        finally {
+            this.operations.delete(operation.controller);
+            operation.cleanup();
+        }
+    }
+    async fetchCatalog(credentialArg, signalArg) {
+        const tokenData = toTokenData(credentialArg);
+        const accountId = tokenData.tokenInfo.chatgptAccountId;
+        const url = `${OPENAI_CHATGPT_CODEX_BASE_URL}/models?client_version=${encodeURIComponent(defaultClientVersion)}`;
+        let response;
+        let onAbort;
+        try {
+            const fetchPromise = this.fetchImplementation(url, {
+                method: 'GET',
+                redirect: 'error',
+                signal: signalArg,
+                headers: {
+                    Accept: 'application/json',
+                    Authorization: `Bearer ${credentialArg.accessToken}`,
+                    ...(accountId ? { 'ChatGPT-Account-ID': accountId } : {}),
+                    ...(tokenData.tokenInfo.chatgptAccountIsFedramp ? { 'X-OpenAI-Fedramp': 'true' } : {}),
+                    originator: this.originator,
+                    version: defaultClientVersion,
+                },
+            });
+            void fetchPromise.then((lateResponse) => {
+                if (signalArg.aborted)
+                    void lateResponse.body?.cancel().catch(() => undefined);
+            }).catch(() => undefined);
+            const aborted = new Promise((_resolve, reject) => {
+                onAbort = () => reject(createSmartAiProviderError('ABORTED'));
+                signalArg.addEventListener('abort', onAbort, { once: true });
+                if (signalArg.aborted)
+                    onAbort();
+            });
+            response = await Promise.race([fetchPromise, aborted]);
+        }
+        catch {
+            if (signalArg.aborted)
+                throw createSmartAiProviderError('ABORTED');
+            throw createSmartAiProviderError('NETWORK_FAILED');
+        }
+        finally {
+            if (onAbort)
+                signalArg.removeEventListener('abort', onAbort);
+        }
+        if (!response.ok) {
+            await response.body?.cancel().catch(() => undefined);
+            throw new ModelHttpError(response.status);
+        }
+        return projectCatalog(await readBoundedJson(response, signalArg, maximumCatalogBytes));
+    }
+    encodeCursor(payloadArg) {
+        const body = plugins.Buffer.from(JSON.stringify(payloadArg), 'utf8').toString('base64url');
+        const mac = plugins.crypto.createHmac('sha256', this.cursorKey).update(body, 'ascii').digest('base64url');
+        return `v1.${body}.${mac}`;
+    }
+    decodeCursor(cursorArg) {
+        const parts = cursorArg.split('.');
+        if (parts.length !== 3 || parts[0] !== 'v1') {
+            throw createSmartAiProviderError('INVALID_ARGUMENT');
+        }
+        const expectedMac = plugins.crypto.createHmac('sha256', this.cursorKey)
+            .update(parts[1], 'ascii')
+            .digest();
+        let actualMac;
+        let payload;
+        try {
+            actualMac = plugins.Buffer.from(parts[2], 'base64url');
+            payload = JSON.parse(plugins.Buffer.from(parts[1], 'base64url').toString('utf8'));
+        }
+        catch {
+            throw createSmartAiProviderError('INVALID_ARGUMENT');
+        }
+        if (actualMac.byteLength !== expectedMac.byteLength || !plugins.crypto.timingSafeEqual(actualMac, expectedMac)) {
+            throw createSmartAiProviderError('INVALID_ARGUMENT');
+        }
+        if (!isRecord(payload)
+            || Object.keys(payload).length !== 5
+            || payload.version !== 1
+            || payload.projectionVersion !== 1
+            || typeof payload.digest !== 'string'
+            || !/^[A-Za-z0-9_-]{43}$/.test(payload.digest)
+            || typeof payload.includeHidden !== 'boolean'
+            || !Number.isSafeInteger(payload.offset)
+            || payload.offset < 0) {
+            throw createSmartAiProviderError('INVALID_ARGUMENT');
+        }
+        return payload;
+    }
+    async listModels(credentialArg, optionsArg = {}) {
+        this.requireOpen();
+        toTokenData(credentialArg);
+        const options = normalizeModelListOptions(optionsArg);
+        const operation = createOperation(options, defaultOperationTimeoutMs);
+        this.operations.add(operation.controller);
+        try {
+            let catalog;
+            try {
+                catalog = await this.fetchCatalog(credentialArg, operation.signal);
+            }
+            catch (errorArg) {
+                if (!(errorArg instanceof ModelHttpError) || errorArg.status !== 401)
+                    throw errorArg;
+                return { success: false, errorCode: 'CREDENTIAL_REFRESH_REQUIRED' };
+            }
+            const filtered = options.includeHidden ? catalog : catalog.filter((model) => !model.hidden);
+            const digest = plugins.crypto.createHash('sha256').update(JSON.stringify(filtered)).digest('base64url');
+            let offset = 0;
+            if (options.cursor !== undefined) {
+                const cursor = this.decodeCursor(options.cursor);
+                if (cursor.digest !== digest
+                    || cursor.includeHidden !== options.includeHidden
+                    || cursor.offset > filtered.length) {
+                    throw createSmartAiProviderError('INVALID_ARGUMENT');
+                }
+                offset = cursor.offset;
+            }
+            const models = filtered.slice(offset, offset + options.limit);
+            const nextOffset = offset + models.length;
+            const nextCursor = nextOffset < filtered.length
+                ? this.encodeCursor({
+                    version: 1,
+                    projectionVersion: 1,
+                    digest,
+                    includeHidden: options.includeHidden,
+                    offset: nextOffset,
+                })
+                : undefined;
+            return {
+                success: true,
+                models,
+                ...(nextCursor === undefined ? {} : { nextCursor }),
+            };
+        }
+        catch (errorArg) {
+            if (errorArg instanceof SmartAiProviderError && errorArg.code === 'INVALID_ARGUMENT') {
+                throw errorArg;
+            }
+            return {
+                success: false,
+                errorCode: classifyOperationError(errorArg, operation, 'MODEL_LIST_FAILED'),
+            };
+        }
+        finally {
+            this.operations.delete(operation.controller);
+            operation.cleanup();
+        }
+    }
+    async fetchAccountRateLimits(credentialArg, signalArg) {
+        const tokenData = toTokenData(credentialArg);
+        const accountId = tokenData.tokenInfo.chatgptAccountId;
+        let response;
+        let onAbort;
+        try {
+            const fetchPromise = this.fetchImplementation(accountRateLimitsUrl, {
+                method: 'GET',
+                redirect: 'error',
+                signal: signalArg,
+                headers: {
+                    Accept: 'application/json',
+                    Authorization: `Bearer ${credentialArg.accessToken}`,
+                    ...(accountId ? { 'ChatGPT-Account-Id': accountId } : {}),
+                    ...(tokenData.tokenInfo.chatgptAccountIsFedramp ? { 'X-OpenAI-Fedramp': 'true' } : {}),
+                    'User-Agent': this.originator,
+                },
+            });
+            void fetchPromise.then((lateResponse) => {
+                if (signalArg.aborted)
+                    void lateResponse.body?.cancel().catch(() => undefined);
+            }).catch(() => undefined);
+            const aborted = new Promise((_resolve, reject) => {
+                onAbort = () => reject(createSmartAiProviderError('ABORTED'));
+                signalArg.addEventListener('abort', onAbort, { once: true });
+                if (signalArg.aborted)
+                    onAbort();
+            });
+            response = await Promise.race([fetchPromise, aborted]);
+        }
+        catch {
+            if (signalArg.aborted)
+                throw createSmartAiProviderError('ABORTED');
+            throw createSmartAiProviderError('NETWORK_FAILED');
+        }
+        finally {
+            if (onAbort)
+                signalArg.removeEventListener('abort', onAbort);
+        }
+        if (!response.ok) {
+            await response.body?.cancel().catch(() => undefined);
+            throw new AccountRateLimitsHttpError(response.status);
+        }
+        return projectAccountRateLimits(await readBoundedJson(response, signalArg, maximumAccountRateLimitsBytes), this.now().toISOString());
+    }
+    async getAccountRateLimits(credentialArg, optionsArg = {}) {
+        this.requireOpen();
+        toTokenData(credentialArg);
+        const operation = createOperation(optionsArg, defaultOperationTimeoutMs);
+        this.operations.add(operation.controller);
+        try {
+            try {
+                const rateLimits = await this.fetchAccountRateLimits(credentialArg, operation.signal);
+                return { success: true, rateLimits };
+            }
+            catch (errorArg) {
+                if (!(errorArg instanceof AccountRateLimitsHttpError) || errorArg.status !== 401) {
+                    throw errorArg;
+                }
+                return { success: false, errorCode: 'CREDENTIAL_REFRESH_REQUIRED' };
+            }
+        }
+        catch (errorArg) {
+            return {
+                success: false,
+                errorCode: classifyOperationError(errorArg, operation, 'ACCOUNT_RATE_LIMITS_FAILED'),
+            };
+        }
+        finally {
+            this.operations.delete(operation.controller);
+            operation.cleanup();
+        }
+    }
+    async logoutCredential(credentialArg, optionsArg = {}) {
+        this.requireOpen();
+        toTokenData(credentialArg);
+        const operation = createOperation(optionsArg, defaultOperationTimeoutMs);
+        this.operations.add(operation.controller);
+        try {
+            await revokeOpenAiChatGptToken(credentialArg.refreshToken, {
+                ...this.authOptions(operation.signal),
+                tokenTypeHint: 'refresh_token',
+            });
+        }
+        catch {
+            throw createSmartAiProviderError(operation.timedOut ? 'TIMEOUT' : operation.signal.aborted ? 'ABORTED' : 'NETWORK_FAILED');
+        }
+        finally {
+            this.operations.delete(operation.controller);
+            operation.cleanup();
+        }
+    }
+    async dispose() {
+        if (this.disposePromise)
+            return this.disposePromise;
+        this.closed = true;
+        const disposeAttempt = (async () => {
+            for (const operation of this.operations)
+                operation.abort();
+            const results = await Promise.allSettled([...this.handles].map((handle) => handle.close()));
+            const operationDeadline = Date.now() + 5_000;
+            while (this.operations.size > 0 && Date.now() < operationDeadline) {
+                await new Promise((resolve) => setTimeout(resolve, 10));
+            }
+            if (results.some((result) => result.status === 'rejected')) {
+                throw createSmartAiProviderError('CLOSED');
+            }
+            if (this.operations.size > 0)
+                throw createSmartAiProviderError('CLOSED');
+            this.handles.clear();
+            this.cursorKey.fill(0);
+        })();
+        this.disposePromise = disposeAttempt;
+        try {
+            await disposeAttempt;
+        }
+        catch (error) {
+            this.disposePromise = undefined;
+            throw error;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smartai.providers.openai.js","sourceRoot":"","sources":["../ts_openai_account/smartai.providers.openai.ts"],"names":[],"mappings":"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"}