dsh-subscriptions 0.2.0 → 0.2.2

package/lib/providers/codex.js

@@ -3,13 +3,13 @@
  * Codex CLI client id, and streaming against the ChatGPT backend Responses
  * endpoint.
  */
-import { createHash, randomUUID } from 'node:crypto';
-import { attributionHeaders, EMPTY_RESPONSE_CODE, errorChain, LlmAdapter, LlmError, ReasoningEffortId } from '@deepseek-ai/dsh-llm';
+import { createHash } from 'node:crypto';
+import { attributionHeaders, EMPTY_RESPONSE_CODE, errorChain, LlmAdapter, LlmError, ReasoningEffortId, } from '@deepseek-ai/dsh-llm';
 import { decodeJwtPayload } from '../auth/jwt.js';
 import { resolveImages } from '../translate/resolved.js';
-import { streamResponses, toResponsesInput, toResponsesTools } from '../translate/responses.js';
+import { streamResponses, toResponsesInput, toResponsesTools, } from '../translate/responses.js';
 import { deterministicSessionId, effortDisplayName, httpLlmError, idleWatchdog, mapFetchFailure, mergeReasoning, ModelCatalogCache, discoverAcrossAccounts, discoverOrRetryAuth, isDiscoveryAborted, isDiscoveryAuthFailure, isMissingOrInvalidCredential, parseProviderJson, oauthEndpointError, OAuthEndpointError, } from './common.js';
-import { AccountTokenManager, DISCOVERY_TIMEOUT_MS, unionAccountCatalogs } from './accounts.js';
+import { AccountTokenManager, DISCOVERY_TIMEOUT_MS, unionAccountCatalogs, } from './accounts.js';
 import { hostFetch } from '../http.js';
 import { DEFAULT_RATE_LIMIT_WAIT, DEFAULT_RETRY, jsonBody, resetFromFields, subscriptionRetryPolicy, } from './rate-limit.js';
 export const CODEX_CLIENT_ID = 'app_EMoamEEZ73f0CkXaXp7hrann';
@@ -27,7 +27,12 @@ export const CODEX_PREEMPT_MS = 5 * 60_000;
  * carries `usage_limit_reached` with the seconds left on the window — the case
  * that used to classify as a terminal quota and never be retried at all.
  */
-const CODEX_RESET_FIELDS = ['resets_in_seconds', 'reset_after_seconds', 'resets_at', 'reset_at'];
+const CODEX_RESET_FIELDS = [
+    'resets_in_seconds',
+    'reset_after_seconds',
+    'resets_at',
+    'reset_at',
+];
 /**
  * Reads the reset instant of the Codex window that rejected a request.
  *
@@ -40,8 +45,8 @@ const CODEX_RESET_FIELDS = ['resets_in_seconds', 'reset_after_seconds', 'resets_
  */
 export const codexRateLimitReset = (_response, body, now) => resetFromFields(jsonBody(body), CODEX_RESET_FIELDS, now);
 /** Default instruction when the request carries no system prompt. */
-const DEFAULT_CODEX_INSTRUCTIONS = 'You are Codex, a coding agent based on GPT-5. '
-    + 'Help the user with their software engineering tasks.';
+const DEFAULT_CODEX_INSTRUCTIONS = 'You are Codex, a coding agent based on GPT-5. ' +
+    'Help the user with their software engineering tasks.';
 /** Refresh-grant rejections that mean the login is gone for good. */
 const PERMANENT_REFRESH_CODES = new Set([
     'refresh_token_expired',
@@ -122,13 +127,16 @@ export function codexProfileClaims(idToken) {
         ? auth.chatgpt_plan_type
         : undefined;
     return {
-        ...typeof email === 'string' && email.length > 0 ? { emailAddress: email } : {},
-        ...typeof plan === 'string' && plan.length > 0 ? { planType: plan } : {},
+        ...(typeof email === 'string' && email.length > 0
+            ? { emailAddress: email }
+            : {}),
+        ...(typeof plan === 'string' && plan.length > 0 ? { planType: plan } : {}),
     };
 }
 /** Build a session from a token response; expires_in wins, JWT exp is the fallback. */
 function codexSession(tokens, fallback) {
-    if (typeof tokens.access_token !== 'string' || tokens.access_token.length === 0) {
+    if (typeof tokens.access_token !== 'string' ||
+        tokens.access_token.length === 0) {
         throw new Error('codex token endpoint returned no access token');
     }
     const refreshToken = tokens.refresh_token ?? fallback?.refreshToken;
@@ -149,8 +157,12 @@ function codexSession(tokens, fallback) {
     // one keeps the claims the stored session already had.
     const idToken = tokens.id_token ?? fallback?.idToken;
     const claims = {
-        ...fallback?.emailAddress === undefined ? {} : { emailAddress: fallback.emailAddress },
-        ...fallback?.planType === undefined ? {} : { planType: fallback.planType },
+        ...(fallback?.emailAddress === undefined
+            ? {}
+            : { emailAddress: fallback.emailAddress }),
+        ...(fallback?.planType === undefined
+            ? {}
+            : { planType: fallback.planType }),
         ...codexProfileClaims(tokens.id_token),
     };
     return {
@@ -160,7 +172,7 @@ function codexSession(tokens, fallback) {
         accountId: tokens.id_token === undefined && fallback !== undefined
             ? fallback.accountId
             : accountIdOf(tokens.id_token),
-        ...idToken === undefined ? {} : { idToken },
+        ...(idToken === undefined ? {} : { idToken }),
         ...claims,
     };
 }
@@ -185,7 +197,7 @@ export async function exchangeCodexCode(code, verifier, redirectUri) {
     });
     if (!response.ok)
         throw await oauthEndpointError(response, 'codex');
-    return codexSession(await parseProviderJson(response, 'codex token exchange'));
+    return codexSession((await parseProviderJson(response, 'codex token exchange')));
 }
 /**
  * Refresh a codex session (JSON grant — unlike the code exchange).
@@ -204,7 +216,7 @@ export async function refreshCodex(session) {
     });
     if (!response.ok)
         throw await oauthEndpointError(response, 'codex');
-    return codexSession(await parseProviderJson(response, 'codex token refresh'), session);
+    return codexSession((await parseProviderJson(response, 'codex token refresh')), session);
 }
 /**
  * Whether a codex refresh failure means the login is permanently gone.
@@ -212,9 +224,9 @@ export async function refreshCodex(session) {
  * @returns true when re-login is the only fix.
  */
 export function isCodexPermanentRefreshError(error) {
-    return error instanceof OAuthEndpointError
-        && error.oauthCode !== undefined
-        && PERMANENT_REFRESH_CODES.has(error.oauthCode);
+    return (error instanceof OAuthEndpointError &&
+        error.oauthCode !== undefined &&
+        PERMANENT_REFRESH_CODES.has(error.oauthCode));
 }
 export const CODEX_USAGE_URL = 'https://chatgpt.com/backend-api/wham/usage';
 export const CODEX_RESET_CREDITS_URL = 'https://chatgpt.com/backend-api/wham/rate-limit-reset-credits';
@@ -235,22 +247,29 @@ export async function fetchCodexResetCredits(session, fetchFn = hostFetch, signa
             accept: 'application/json',
             ...attributionHeaders(),
         },
-        ...signal === undefined ? {} : { signal },
+        ...(signal === undefined ? {} : { signal }),
     });
     if (!response.ok)
         throw await oauthEndpointError(response, 'codex reset credits');
-    const payload = await parseProviderJson(response, 'codex reset credits');
+    const payload = (await parseProviderJson(response, 'codex reset credits'));
     if (!Array.isArray(payload?.credits))
         throw new Error('codex reset credits: unexpected response (missing credits array)');
     return payload.credits.flatMap((value) => {
         if (typeof value !== 'object' || value === null)
             return [];
         const credit = value;
-        if (credit.status !== 'available' || credit.reset_type !== 'codex_rate_limits')
+        if (credit.status !== 'available' ||
+            credit.reset_type !== 'codex_rate_limits')
             return [];
         const grantedAt = parseResetDate(credit.granted_at);
         const expiresAt = parseResetDate(credit.expires_at);
-        return [{ ...(typeof credit.id === 'string' ? { id: credit.id } : {}), ...(grantedAt === undefined ? {} : { grantedAt }), ...(expiresAt === undefined ? {} : { expiresAt }) }];
+        return [
+            {
+                ...(typeof credit.id === 'string' ? { id: credit.id } : {}),
+                ...(grantedAt === undefined ? {} : { grantedAt }),
+                ...(expiresAt === undefined ? {} : { expiresAt }),
+            },
+        ];
     });
 }
 /** Submit one explicit reset; ambiguous or unconfirmed responses throw without retry. */
@@ -260,16 +279,18 @@ export async function consumeCodexResetCredit(session, creditId, requestId, fetc
         headers: {
             authorization: 'Bearer ' + session.accessToken,
             'chatgpt-account-id': session.accountId,
-            originator: 'Codex Desktop', 'openai-beta': 'codex-1',
-            'content-type': 'application/json', accept: 'application/json',
+            originator: 'Codex Desktop',
+            'openai-beta': 'codex-1',
+            'content-type': 'application/json',
+            accept: 'application/json',
             ...attributionHeaders(),
         },
         body: JSON.stringify({ redeem_request_id: requestId, credit_id: creditId }),
-        ...signal === undefined ? {} : { signal },
+        ...(signal === undefined ? {} : { signal }),
     });
     if (!response.ok)
         throw await oauthEndpointError(response, 'codex consume reset');
-    const payload = await parseProviderJson(response, 'codex consume reset');
+    const payload = (await parseProviderJson(response, 'codex consume reset'));
     if (payload?.code !== 'reset')
         throw new Error('Reset was not confirmed. Verify the account in Codex before retrying.');
 }
@@ -301,24 +322,30 @@ function codexUsageWindow(value, fallbackKind) {
     if (typeof value !== 'object' || value === null)
         return undefined;
     const window = value;
-    if (typeof window.used_percent !== 'number' || !Number.isFinite(window.used_percent))
+    if (typeof window.used_percent !== 'number' ||
+        !Number.isFinite(window.used_percent))
         return undefined;
     let resetsAt;
     if (typeof window.reset_at === 'number' && window.reset_at > 0) {
         resetsAt = window.reset_at * 1000;
     }
-    else if (typeof window.reset_after_seconds === 'number' && window.reset_after_seconds > 0) {
+    else if (typeof window.reset_after_seconds === 'number' &&
+        window.reset_after_seconds > 0) {
         resetsAt = Date.now() + window.reset_after_seconds * 1000;
     }
     return {
         kind: codexWindowKind(window, fallbackKind),
-        ...typeof window.limit_window_seconds === 'number' && Number.isFinite(window.limit_window_seconds)
-            && window.limit_window_seconds > 0 ? {
-            // wham reports the duration and reset of this same quota window.
-            windowDurationMs: window.limit_window_seconds * 1000, fixedWindow: true,
-        } : {},
+        ...(typeof window.limit_window_seconds === 'number' &&
+            Number.isFinite(window.limit_window_seconds) &&
+            window.limit_window_seconds > 0
+            ? {
+                // wham reports the duration and reset of this same quota window.
+                windowDurationMs: window.limit_window_seconds * 1000,
+                fixedWindow: true,
+            }
+            : {}),
         usedPercent: window.used_percent,
-        ...resetsAt === undefined ? {} : { resetsAt },
+        ...(resetsAt === undefined ? {} : { resetsAt }),
     };
 }
 /**
@@ -337,17 +364,17 @@ function codexUsageWindow(value, fallbackKind) {
 export async function fetchCodexUsage(session, fetchFn = hostFetch, signal) {
     const response = await fetchFn(CODEX_USAGE_URL, {
         headers: {
-            'authorization': `Bearer ${session.accessToken}`,
+            authorization: `Bearer ${session.accessToken}`,
             'chatgpt-account-id': session.accountId,
-            'originator': 'codex_cli_rs',
-            'accept': 'application/json',
+            originator: 'codex_cli_rs',
+            accept: 'application/json',
             ...attributionHeaders(),
         },
-        ...signal === undefined ? {} : { signal },
+        ...(signal === undefined ? {} : { signal }),
     });
     if (!response.ok)
         throw await oauthEndpointError(response, 'codex usage');
-    const payload = await parseProviderJson(response, 'codex usage');
+    const payload = (await parseProviderJson(response, 'codex usage'));
     const windows = [];
     const primary = codexUsageWindow(payload.rate_limit?.primary_window, 'session');
     const secondary = codexUsageWindow(payload.rate_limit?.secondary_window, 'weekly');
@@ -358,9 +385,9 @@ export async function fetchCodexUsage(session, fetchFn = hostFetch, signal) {
     return {
         supported: true,
         windows,
-        ...typeof payload.plan_type === 'string' && payload.plan_type.length > 0
+        ...(typeof payload.plan_type === 'string' && payload.plan_type.length > 0
             ? { plan: payload.plan_type }
-            : {},
+            : {}),
     };
 }
 export const CODEX_MODELS_URL = 'https://chatgpt.com/backend-api/codex/models';
@@ -384,8 +411,7 @@ export function codexClientVersion(value = CODEX_CLIENT_VERSION) {
  * wire value, or the legacy `additional_speed_tiers` "fast" entry.
  */
 function supportsFastTier(entry) {
-    return (entry.service_tiers ?? []).some(tier => tier.id === CODEX_FAST_SERVICE_TIER)
-        || (entry.additional_speed_tiers ?? []).includes(CODEX_FAST_SPEED_TIER);
+    return ((entry.service_tiers ?? []).some((tier) => tier.id === CODEX_FAST_SERVICE_TIER) || (entry.additional_speed_tiers ?? []).includes(CODEX_FAST_SPEED_TIER));
 }
 /**
  * Fetch the live codex model catalog with the session's auth headers.
@@ -400,17 +426,17 @@ export async function fetchCodexModels(session, fetchFn = hostFetch, signal, cli
     const url = `${CODEX_MODELS_URL}?client_version=${encodeURIComponent(version)}`;
     const response = await fetchFn(url, {
         headers: {
-            'authorization': `Bearer ${session.accessToken}`,
+            authorization: `Bearer ${session.accessToken}`,
             'chatgpt-account-id': session.accountId,
-            'originator': 'codex_cli_rs',
-            'accept': 'application/json',
+            originator: 'codex_cli_rs',
+            accept: 'application/json',
             ...attributionHeaders(),
         },
-        ...signal === undefined ? {} : { signal },
+        ...(signal === undefined ? {} : { signal }),
     });
     if (!response.ok)
         throw await oauthEndpointError(response, 'codex models');
-    const payload = await parseProviderJson(response, 'codex models');
+    const payload = (await parseProviderJson(response, 'codex models'));
     if (!Array.isArray(payload.models))
         throw new Error('codex models endpoint returned no models array');
     const discovered = [];
@@ -424,15 +450,20 @@ export async function fetchCodexModels(session, fetchFn = hostFetch, signal, cli
         // "ultra" is a Codex-client mode (max reasoning + automatic sub-agent
         // delegation), not a wire value: the Responses API rejects it with HTTP 400.
         const efforts = (entry.supported_reasoning_levels ?? [])
-            .filter(level => typeof level.effort === 'string' && level.effort.length > 0 && level.effort !== 'ultra')
-            .map(level => ({
+            .filter((level) => typeof level.effort === 'string' &&
+            level.effort.length > 0 &&
+            level.effort !== 'ultra')
+            .map((level) => ({
             id: ReasoningEffortId(level.effort),
             name: effortDisplayName(level.effort),
-            ...level.description === undefined ? {} : { description: level.description },
+            ...(level.description === undefined
+                ? {}
+                : { description: level.description }),
         }));
-        const defaultEffort = typeof entry.default_reasoning_level === 'string'
-            && entry.default_reasoning_level.length > 0
-            && efforts.some(effort => effort.id === ReasoningEffortId(entry.default_reasoning_level))
+        const defaultEffort = typeof entry.default_reasoning_level === 'string' &&
+            entry.default_reasoning_level.length > 0 &&
+            efforts.some((effort) => effort.id ===
+                ReasoningEffortId(entry.default_reasoning_level))
             ? ReasoningEffortId(entry.default_reasoning_level)
             : undefined;
         const model = {
@@ -440,24 +471,33 @@ export async function fetchCodexModels(session, fetchFn = hostFetch, signal, cli
             name: typeof entry.display_name === 'string' && entry.display_name.length > 0
                 ? entry.display_name
                 : entry.slug,
-            ...typeof entry.description === 'string' && entry.description.length > 0
+            ...(typeof entry.description === 'string' && entry.description.length > 0
                 ? { description: entry.description }
-                : {},
-            ...typeof entry.context_window === 'number' && entry.context_window > 0
+                : {}),
+            ...(typeof entry.context_window === 'number' && entry.context_window > 0
                 ? { contextWindow: entry.context_window }
-                : {},
-            ...Number.isSafeInteger(entry.max_context_window) && entry.max_context_window > 0
+                : {}),
+            ...(Number.isSafeInteger(entry.max_context_window) &&
+                entry.max_context_window > 0
                 ? { maxContextWindow: entry.max_context_window }
-                : {},
-            ...typeof entry.priority === 'number' ? { priority: entry.priority } : {},
-            ...efforts.length > 0
-                ? { reasoning: { efforts, ...defaultEffort === undefined ? {} : { defaultEffort } } }
-                : {},
-            ...supportsFastTier(entry) ? { fastTier: true } : {},
+                : {}),
+            ...(typeof entry.priority === 'number'
+                ? { priority: entry.priority }
+                : {}),
+            ...(efforts.length > 0
+                ? {
+                    reasoning: {
+                        efforts,
+                        ...(defaultEffort === undefined ? {} : { defaultEffort }),
+                    },
+                }
+                : {}),
+            ...(supportsFastTier(entry) ? { fastTier: true } : {}),
         };
         discovered.push(model);
     }
-    discovered.sort((a, b) => (a.priority ?? Number.MAX_SAFE_INTEGER) - (b.priority ?? Number.MAX_SAFE_INTEGER));
+    discovered.sort((a, b) => (a.priority ?? Number.MAX_SAFE_INTEGER) -
+        (b.priority ?? Number.MAX_SAFE_INTEGER));
     // An empty catalog from a 200 response means the backend gated us out (e.g.
     // client_version too old): surface it as a discovery failure so the adapter
     // falls back to the static catalog instead of vanishing from the picker.
@@ -478,7 +518,8 @@ const CODEX_CALL_ID_PREFIX = 'call_';
 function normalizeCodexCallIds(input) {
     const mapping = new Map();
     const used = new Set();
-    const callId = (item) => (item.type === 'function_call' || item.type === 'function_call_output') && typeof item.call_id === 'string'
+    const callId = (item) => (item.type === 'function_call' || item.type === 'function_call_output') &&
+        typeof item.call_id === 'string'
         ? item.call_id
         : undefined;
     for (const item of input) {
@@ -531,20 +572,28 @@ export function reconcileResponsesToolCalls(input) {
     for (const item of input) {
         if (item.type === 'function_call' && typeof item.call_id === 'string')
             calls.add(item.call_id);
-        else if (item.type === 'function_call_output' && typeof item.call_id === 'string')
+        else if (item.type === 'function_call_output' &&
+            typeof item.call_id === 'string')
             outputs.add(item.call_id);
     }
-    const missing = new Set([...calls].filter(callId => !outputs.has(callId)));
-    if (missing.size === 0 && [...outputs].every(callId => calls.has(callId)))
+    const missing = new Set([...calls].filter((callId) => !outputs.has(callId)));
+    if (missing.size === 0 && [...outputs].every((callId) => calls.has(callId)))
         return input;
     const balanced = [];
     for (const item of input) {
-        if (item.type === 'function_call_output' && (typeof item.call_id !== 'string' || !calls.has(item.call_id))) {
+        if (item.type === 'function_call_output' &&
+            (typeof item.call_id !== 'string' || !calls.has(item.call_id))) {
             continue;
         }
         balanced.push(item);
-        if (item.type === 'function_call' && typeof item.call_id === 'string' && missing.delete(item.call_id)) {
-            balanced.push({ type: 'function_call_output', call_id: item.call_id, output: CODEX_UNKNOWN_TOOL_OUTCOME });
+        if (item.type === 'function_call' &&
+            typeof item.call_id === 'string' &&
+            missing.delete(item.call_id)) {
+            balanced.push({
+                type: 'function_call_output',
+                call_id: item.call_id,
+                output: CODEX_UNKNOWN_TOOL_OUTCOME,
+            });
         }
     }
     return balanced;
@@ -573,17 +622,28 @@ export function codexRequestBody(options, resolved, fast) {
         // Omit tool controls for tool-less requests, matching the other adapters.
         // This is request-shape consistency, not a claim that Codex rejects the
         // controls when no tools are supplied.
-        ...options.tools !== undefined && options.tools.length > 0
-            ? { tools: toResponsesTools(options.tools, { strict: false }), tool_choice: 'auto', parallel_tool_calls: true }
-            : {},
-        ...options.reasoningEffort !== undefined
-            ? { reasoning: { effort: codexWireEffort(String(options.reasoningEffort)), summary: 'auto' } }
-            : {},
+        ...(options.tools !== undefined && options.tools.length > 0
+            ? {
+                tools: toResponsesTools(options.tools, { strict: false }),
+                tool_choice: 'auto',
+                parallel_tool_calls: true,
+            }
+            : {}),
+        ...(options.reasoningEffort !== undefined
+            ? {
+                reasoning: {
+                    effort: codexWireEffort(String(options.reasoningEffort)),
+                    summary: 'auto',
+                },
+            }
+            : {}),
         store: false,
         stream: true,
         include: ['reasoning.encrypted_content'],
-        ...options.sessionId !== undefined ? { prompt_cache_key: String(options.sessionId) } : {},
-        ...fast ? { service_tier: CODEX_FAST_SERVICE_TIER } : {},
+        ...(options.sessionId !== undefined
+            ? { prompt_cache_key: String(options.sessionId) }
+            : {}),
+        ...(fast ? { service_tier: CODEX_FAST_SERVICE_TIER } : {}),
     };
 }
 /** Codex wire adapter: one instance serves the `codex` provider route. */
@@ -602,7 +662,8 @@ export class CodexAdapter extends LlmAdapter {
     }
     /** Discovery fetcher: resolves the session through the refresh-aware path. */
     async fetchCatalog(account, signal) {
-        const version = this.options.clientVersion ?? await this.options.resolveClientVersion?.();
+        const version = this.options.clientVersion ??
+            (await this.options.resolveClientVersion?.());
         signal?.throwIfAborted();
         return fetchCodexModels(await this.options.tokens.session(account), this.options.fetchFn, signal, version);
     }
@@ -619,7 +680,9 @@ export class CodexAdapter extends LlmAdapter {
             this.accountCatalogs.get(account)?.invalidate();
             this.accountCatalogs.delete(account);
         }
-        if (account === undefined || this.catalogOwner === account || this.catalogOwner === undefined) {
+        if (account === undefined ||
+            this.catalogOwner === account ||
+            this.catalogOwner === undefined) {
             this.catalogOwner = undefined;
             this.catalog.invalidate();
         }
@@ -644,13 +707,15 @@ export class CodexAdapter extends LlmAdapter {
     }
     /** Picker rows for discovered entries (the wire id doubles as the route id). */
     listed(provider, models) {
-        return models.map(model => ({
+        return models.map((model) => ({
             provider,
             id: model.id,
             name: model.name,
-            ...model.description === undefined ? {} : { description: model.description },
+            ...(model.description === undefined
+                ? {}
+                : { description: model.description }),
             inputModalities: CODEX_MODALITIES,
-            ...model.priority === undefined ? {} : { priority: model.priority },
+            ...(model.priority === undefined ? {} : { priority: model.priority }),
         }));
     }
     /**
@@ -659,7 +724,8 @@ export class CodexAdapter extends LlmAdapter {
      * listed a model minutes ago is still a better answer than "no models".
      */
     async lastKnownOwnModels(provider, account) {
-        if (!this.options.discovery || !await this.options.tokens.hasSession(account))
+        if (!this.options.discovery ||
+            !(await this.options.tokens.hasSession(account)))
             return undefined;
         const known = (await this.catalogFor(account)).lastKnown();
         return known === undefined ? undefined : this.listed(provider, known);
@@ -671,7 +737,7 @@ export class CodexAdapter extends LlmAdapter {
         return subscriptionRetryPolicy(DEFAULT_RETRY, this.options.rateLimit ?? DEFAULT_RATE_LIMIT_WAIT, `codex: provider "${provider}" retryPolicy`);
     }
     staticModels(provider) {
-        return this.options.models.map(model => ({
+        return this.options.models.map((model) => ({
             provider,
             id: model.id,
             name: model.name ?? model.id,
@@ -684,19 +750,22 @@ export class CodexAdapter extends LlmAdapter {
         if (pool === undefined)
             return own;
         const extra = await pool.modelsForProvider(provider);
-        const seen = new Set(own.map(model => model.id));
+        const seen = new Set(own.map((model) => model.id));
         // Account pools reuse the catalog row; only configured tiers are extra.
-        return [...own, ...extra.filter(model => !seen.has(model.id))];
+        return [...own, ...extra.filter((model) => !seen.has(model.id))];
     }
     /** The provider's own catalog: union of every account, or one account when named. */
     async listOwnModels(provider, account, signal) {
         if (account === undefined) {
-            const accounts = (await this.options.tokens.list()).map(entry => entry.key);
+            const accounts = (await this.options.tokens.list()).map((entry) => entry.key);
             if (accounts.length === 0)
                 return [];
-            return unionAccountCatalogs(accounts, (key, accountSignal) => this.listOwnModels(provider, key, accountSignal), { timeoutMs: this.options.discoveryTimeoutMs ?? DISCOVERY_TIMEOUT_MS, ...signal === undefined ? {} : { signal } });
+            return unionAccountCatalogs(accounts, (key, accountSignal) => this.listOwnModels(provider, key, accountSignal), {
+                timeoutMs: this.options.discoveryTimeoutMs ?? DISCOVERY_TIMEOUT_MS,
+                ...(signal === undefined ? {} : { signal }),
+            });
         }
-        if (!await this.options.tokens.hasSession(account)) {
+        if (!(await this.options.tokens.hasSession(account))) {
             return [];
         }
         if (!this.options.discovery)
@@ -706,7 +775,7 @@ export class CodexAdapter extends LlmAdapter {
             // The fetcher runs only on a cache miss, and resolves the session
             // through the refresh-aware path so an expired access token renews here
             // instead of failing discovery into the static fallback.
-            const discovered = await discoverOrRetryAuth(force => this.options.tokens.session(account, force), catalog, () => catalog.get(() => this.fetchCatalog(account, signal)));
+            const discovered = await discoverOrRetryAuth((force) => this.options.tokens.session(account, force), catalog, () => catalog.get(() => this.fetchCatalog(account, signal)));
             return this.listed(provider, discovered);
         }
         catch (error) {
@@ -722,7 +791,9 @@ export class CodexAdapter extends LlmAdapter {
             // the login is revoked server-side. Listing the built-in catalog here
             // would route requests to a dead account and show phantom models.
             if (isDiscoveryAuthFailure(error)) {
-                const who = (await this.options.tokens.peek(account))?.emailAddress ?? account ?? 'default account';
+                const who = (await this.options.tokens.peek(account))?.emailAddress ??
+                    account ??
+                    'default account';
                 this.options.onWarn?.(`codex rejected the login of ${who}; hiding its models until it logs in again (${errorChain(error)})`);
                 return [];
             }
@@ -749,12 +820,12 @@ export class CodexAdapter extends LlmAdapter {
         if (!this.options.discovery)
             return undefined;
         const accounts = account === undefined
-            ? (await this.options.tokens.list()).map(entry => entry.key)
+            ? (await this.options.tokens.list()).map((entry) => entry.key)
             : [account];
         return discoverAcrossAccounts(accounts, async (account) => {
             const catalog = await this.catalogFor(account);
             const models = await catalog.resolve(() => this.fetchCatalog(account));
-            return models?.find(entry => entry.id === model);
+            return models?.find((entry) => entry.id === model);
         });
     }
     /** Whether the discovered catalog advertises a fast tier for this model. */
@@ -768,7 +839,7 @@ export class CodexAdapter extends LlmAdapter {
         // Not logged in → no fast models, so the Speed toggle hides after logout
         // (mirrors the listModels guard above). Union every account: a fast-capable
         // model only the non-default lists (e.g. gpt-5.6-sol) must still show Speed.
-        const accounts = (await this.options.tokens.list()).map(entry => entry.key);
+        const accounts = (await this.options.tokens.list()).map((entry) => entry.key);
         if (accounts.length === 0)
             return [];
         const seen = new Set();
@@ -792,7 +863,8 @@ export class CodexAdapter extends LlmAdapter {
     }
     async resolveModel(provider, model) {
         const pool = this.options.pool?.();
-        if (pool !== undefined && await pool.owns(provider, model)) {
+        if (pool !== undefined &&
+            (await pool.owns(provider, model))) {
             return pool.resolveModel(provider, model);
         }
         return this.resolveOwnModel(provider, model);
@@ -803,17 +875,22 @@ export class CodexAdapter extends LlmAdapter {
         // the static entry wins over the built-in defaults. A configured default
         // effort merges over both.
         const discovered = await this.discovered(model, account);
-        const configured = this.options.models.find(entry => entry.id === model);
+        const configured = this.options.models.find((entry) => entry.id === model);
         // `extendable` only while falling back to the built-in list: that one is
         // known to trail the backend, so a configured level it omits still has to
         // be selectable. A discovered catalog is the truth about what the model
         // accepts, and a stale override must not be forced onto every request.
-        const reasoning = mergeReasoning(this.options.defaultEffortOf?.(model), discovered?.reasoning ?? { efforts: CODEX_EFFORTS, defaultEffort: CODEX_DEFAULT_EFFORT }, { extendable: discovered?.reasoning === undefined });
+        const reasoning = mergeReasoning(this.options.defaultEffortOf?.(model), discovered?.reasoning ?? {
+            efforts: CODEX_EFFORTS,
+            defaultEffort: CODEX_DEFAULT_EFFORT,
+        }, { extendable: discovered?.reasoning === undefined });
         return {
             provider,
             id: model,
             name: discovered?.name ?? configured?.name ?? model,
-            ...discovered?.description === undefined ? {} : { description: discovered.description },
+            ...(discovered?.description === undefined
+                ? {}
+                : { description: discovered.description }),
             inputModalities: configured?.inputModalities ?? CODEX_MODALITIES,
             context: { contextWindow: await this.contextWindowFor(model, account) },
             defaultMaxTokens: configured?.maxTokens ?? CODEX_DEFAULT_MAX_TOKENS,
@@ -823,8 +900,10 @@ export class CodexAdapter extends LlmAdapter {
     /** Account-specific bounds; absent maximum conservatively keeps the advertised default. */
     async contextLimits(model, account) {
         const discovered = await this.discovered(model, account);
-        const configured = this.options.models.find(entry => entry.id === model);
-        const fallback = discovered?.contextWindow ?? configured?.contextWindow ?? CODEX_CONTEXT_WINDOW;
+        const configured = this.options.models.find((entry) => entry.id === model);
+        const fallback = discovered?.contextWindow ??
+            configured?.contextWindow ??
+            CODEX_CONTEXT_WINDOW;
         return { default: fallback, max: discovered?.maxContextWindow ?? fallback };
     }
     async contextWindowFor(model, account) {
@@ -833,7 +912,8 @@ export class CodexAdapter extends LlmAdapter {
     }
     async *stream(options) {
         const pool = this.options.pool?.();
-        if (pool !== undefined && await pool.owns(options.provider, options.model)) {
+        if (pool !== undefined &&
+            (await pool.owns(options.provider, options.model))) {
             yield* pool.stream(options);
             return;
         }
@@ -856,13 +936,17 @@ export class CodexAdapter extends LlmAdapter {
             if (!response.ok) {
                 throw await httpLlmError(response, 'codex API', {
                     rateLimitReset: codexRateLimitReset,
-                    ...this.options.onWarn === undefined ? {} : { onWarn: this.options.onWarn },
+                    ...(this.options.onWarn === undefined
+                        ? {}
+                        : { onWarn: this.options.onWarn }),
                 });
             }
             if (response.body === null) {
                 throw new LlmError('codex API returned no response body', EMPTY_RESPONSE_CODE);
             }
-            yield* streamResponses(response.body, () => { watchdog.pulse(); });
+            yield* streamResponses(response.body, () => {
+                watchdog.pulse();
+            });
         }
         catch (error) {
             throw mapFetchFailure('codex API', error, watchdog, options.signal);
@@ -873,17 +957,17 @@ export class CodexAdapter extends LlmAdapter {
     }
     async request(options, session, signal) {
         const messages = await resolveImages(options.messages, this.options.resolveAttachments?.(), signal);
-        const fast = this.options.speedFor !== undefined
-            && await this.options.speedFor(options.sessionId, options.model);
+        const fast = this.options.speedFor !== undefined &&
+            (await this.options.speedFor(options.sessionId, options.model));
         const body = codexRequestBody(options, toResponsesInput(messages, options.system), fast);
         return hostFetch(CODEX_API_URL, {
             method: 'POST',
             headers: {
-                'authorization': `Bearer ${session.accessToken}`,
+                authorization: `Bearer ${session.accessToken}`,
                 'chatgpt-account-id': session.accountId,
-                'originator': 'codex_cli_rs',
+                originator: 'codex_cli_rs',
                 'session-id': deterministicSessionId(options.sessionId),
-                'accept': 'text/event-stream',
+                accept: 'text/event-stream',
                 'content-type': 'application/json',
                 ...attributionHeaders(),
             },