ldrouter 1.16.2 → 1.16.3

package/dist/server/providers/codex-refresh.js

@@ -1,165 +0,0 @@
-import { getCodexCredentials, getCodexAccountRefreshState, persistCodexRefresh, setCodexAccountHealth } from '../db/repositories/codex-accounts.js';
-import { GatewayError } from '../errors.js';
-/**
- * Maps the credential-layer's opaque error codes onto typed admin-facing errors. Call sites that
- * must not leak a bare 500 wrap their `withCodexCredentials` call in this. Codex fixes credential
- * failures by re-importing the account, not by re-saving a provider API key.
- */
-export function codexCredentialError(error) {
-    const code = error instanceof Error ? error.message : '';
-    if (code === 'account_not_found')
-        return new GatewayError('invalid_request_error', 'Codex account not found', { status: 404 });
-    if (code === 'oauth_refresh_failed' || code === 'invalid_refresh_response' || code === 'credential_unavailable') {
-        return new GatewayError('authentication_error', 'Codex credentials could not be refreshed — re-import the account', { status: 401 });
-    }
-    return error;
-}
-const REFRESH_LEAD_MS = 5 * 60 * 1000;
-const REFRESH_TIMEOUT_MS = 10_000;
-const flights = new Map();
-let refreshClient = defaultRefreshClient;
-let refreshTimeoutMs = REFRESH_TIMEOUT_MS;
-export function configureCodexOAuthRefreshClient(client, timeoutMs = REFRESH_TIMEOUT_MS) {
-    refreshClient = client ?? defaultRefreshClient;
-    refreshTimeoutMs = Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : REFRESH_TIMEOUT_MS;
-}
-export function needsCodexRefresh(account, now = new Date()) {
-    const expires = Date.parse(account.tokenExpiresAt);
-    return !Number.isFinite(expires) || expires - now.getTime() <= REFRESH_LEAD_MS;
-}
-async function defaultRefreshClient(input) {
-    const response = await fetch('https://auth.openai.com/oauth/token', {
-        method: 'POST',
-        headers: { 'content-type': 'application/x-www-form-urlencoded', accept: 'application/json' },
-        body: new URLSearchParams({ grant_type: 'refresh_token', refresh_token: input.refreshToken }),
-        signal: input.signal,
-    });
-    if (!response.ok)
-        throw new Error(`oauth refresh http ${response.status}`);
-    const value = await response.json();
-    if (typeof value.access_token !== 'string' || !value.access_token)
-        throw new Error('invalid refresh response');
-    return {
-        accessToken: value.access_token,
-        refreshToken: typeof value.refresh_token === 'string' ? value.refresh_token : undefined,
-        idToken: typeof value.id_token === 'string' ? value.id_token : undefined,
-        expiresIn: typeof value.expires_in === 'number' ? value.expires_in : undefined,
-        expiresAt: typeof value.expires_at === 'string' ? value.expires_at : undefined,
-    };
-}
-function safeError(_error) {
-    return 'oauth_refresh_failed';
-}
-function markDegraded(accountId, error) {
-    try {
-        setCodexAccountHealth(accountId, 'degraded', error);
-    }
-    catch { /* fail closed */ }
-}
-async function refreshOnce(accountId, now, force) {
-    let state;
-    try {
-        state = getCodexAccountRefreshState(accountId);
-    }
-    catch (error) {
-        markDegraded(accountId, safeError(error));
-        return { ok: false, error: 'oauth_refresh_failed' };
-    }
-    if (!state)
-        return { ok: false, error: 'account_not_found' };
-    if (!force && !needsCodexRefresh(state, now))
-        return { ok: true, expiresAt: state.tokenExpiresAt };
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), refreshTimeoutMs);
-    try {
-        const result = await refreshClient({ refreshToken: state.refreshToken, signal: controller.signal });
-        if (typeof result.accessToken !== 'string' || !result.accessToken) {
-            markDegraded(accountId, 'invalid_refresh_response');
-            return { ok: false, error: 'invalid_refresh_response' };
-        }
-        const expiresAt = result.expiresAt ?? (typeof result.expiresIn === 'number' && Number.isFinite(result.expiresIn) && result.expiresIn > 0
-            ? new Date(now.getTime() + result.expiresIn * 1000).toISOString()
-            : '');
-        const expiresMs = Date.parse(expiresAt);
-        if (!Number.isFinite(expiresMs) || expiresMs <= now.getTime()) {
-            markDegraded(accountId, 'invalid_refresh_response');
-            return { ok: false, error: 'invalid_refresh_response' };
-        }
-        try {
-            persistCodexRefresh(accountId, {
-                accessToken: result.accessToken,
-                refreshToken: result.refreshToken ?? state.refreshToken,
-                idToken: result.idToken ?? state.idToken,
-                expiresAt,
-            });
-        }
-        catch (error) {
-            markDegraded(accountId, safeError(error));
-            return { ok: false, error: 'oauth_refresh_failed' };
-        }
-        return { ok: true, expiresAt };
-    }
-    catch (error) {
-        markDegraded(accountId, safeError(error));
-        return { ok: false, error: 'oauth_refresh_failed' };
-    }
-    finally {
-        clearTimeout(timer);
-    }
-}
-export function refreshCodexAccount(accountId, now = new Date(), force = false) {
-    const existing = flights.get(accountId);
-    if (existing)
-        return existing;
-    const flight = refreshOnce(accountId, now, force).finally(() => flights.delete(accountId));
-    flights.set(accountId, flight);
-    return flight;
-}
-function isUnauthorized(error) {
-    return Boolean(error && typeof error === 'object' && ('status' in error) && ((error.status === 401) || (error.status === 403)));
-}
-/* eslint-disable preserve-caught-error -- raw credential errors must never escape this boundary */
-export async function withCodexCredentials(accountId, fn, now = new Date()) {
-    let state;
-    try {
-        state = getCodexAccountRefreshState(accountId);
-    }
-    catch (error) {
-        markDegraded(accountId, safeError(error));
-        throw new Error('credential_unavailable', { cause: new Error('credential_unavailable') });
-    }
-    if (!state)
-        throw new Error('account_not_found');
-    if (needsCodexRefresh(state, now)) {
-        const refreshed = await refreshCodexAccount(accountId, now);
-        if (!refreshed.ok)
-            throw new Error(refreshed.error, { cause: new Error(refreshed.error) });
-    }
-    let credentials;
-    try {
-        credentials = getCodexCredentials(accountId);
-    }
-    catch (error) {
-        markDegraded(accountId, safeError(error));
-        throw new Error('credential_unavailable', { cause: new Error('credential_unavailable') });
-    }
-    try {
-        return await fn(credentials);
-    }
-    catch (error) {
-        if (!isUnauthorized(error))
-            throw error;
-        const refreshed = await refreshCodexAccount(accountId, now, true);
-        if (!refreshed.ok)
-            throw new Error(refreshed.error, { cause: new Error(refreshed.error) });
-        try {
-            credentials = getCodexCredentials(accountId);
-        }
-        catch (credentialError) {
-            markDegraded(accountId, safeError(credentialError));
-            throw new Error('credential_unavailable', { cause: new Error('credential_unavailable') });
-        }
-        return fn(credentials);
-    }
-}
-/* eslint-enable preserve-caught-error */

package/dist/server/providers/codex-usage.js

@@ -1,192 +0,0 @@
-// Codex account quota: usage snapshot (wham/usage), weekly reset credits, and the
-// 5-hour window auto-start ("auto ping") request. Contracts mirror 9router.
-import { codexRequest, codexHeaders } from './codex.js';
-const USAGE_URL = 'https://chatgpt.com/backend-api/wham/usage';
-const RESET_CREDITS_URL = 'https://chatgpt.com/backend-api/wham/rate-limit-reset-credits';
-const RESET_CREDITS_CONSUME_URL = `${RESET_CREDITS_URL}/consume`;
-const UA = 'codex_cli_rs/0.136.0';
-/** Auto-start ping: only starts a 5-hour window once the streaming body is fully drained. */
-export const CODEX_PING = { model: 'gpt-5.5', text: 'hi', instructions: 'Reply with OK.' };
-/** codex_autostart_enabled accounts are never pinged more often than this. */
-export const CODEX_AUTOSTART_MIN_INTERVAL_MS = 10 * 60 * 1000;
-function numberOr(value, fallback) {
-    if (typeof value === 'number' && Number.isFinite(value))
-        return value;
-    if (typeof value === 'string' && value.trim()) {
-        const parsed = Number(value);
-        if (Number.isFinite(parsed))
-            return parsed;
-    }
-    return fallback;
-}
-function isoOrNull(value) {
-    if (!value)
-        return null;
-    const date = value instanceof Date ? value : new Date(typeof value === 'number' && value < 1e12 ? value * 1000 : value);
-    return Number.isFinite(date.getTime()) ? date.toISOString() : null;
-}
-/** Codex nests the 5h/weekly windows under several upstream key spellings. */
-function limitContainer(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return null;
-    const record = value;
-    return record.rate_limit && typeof record.rate_limit === 'object' ? record.rate_limit : record;
-}
-function innerWindow(container, ...keys) {
-    if (!container)
-        return null;
-    for (const key of keys) {
-        const inner = container[key];
-        if (inner && typeof inner === 'object' && !Array.isArray(inner))
-            return inner;
-    }
-    return null;
-}
-function toQuota(window) {
-    const used = Math.max(0, Math.min(100, numberOr(window.used_percent ?? window.percent_used, 0)));
-    return { used, total: 100, remaining: Math.max(0, 100 - used), resetAt: isoOrNull(window.reset_at ?? window.resets_at ?? window.resetAt) };
-}
-export function readCodexQuotas(body) {
-    const root = (body && typeof body === 'object' ? body : {});
-    const limitIds = root.rate_limits_by_limit_id;
-    const container = limitContainer(root.rate_limit ?? root.rate_limits ?? limitIds?.codex);
-    if (!container)
-        return {};
-    const quotas = {};
-    // Primary window is the 5-hour quota; secondary is the weekly one. Bare objects are treated as primary.
-    const primary = innerWindow(container, 'primary_window', 'primary')
-        ?? ('used_percent' in container || 'percent_used' in container || 'reset_at' in container || 'resets_at' in container ? container : null);
-    if (primary)
-        quotas.session = toQuota(primary);
-    const additional = Array.isArray(root.additional_rate_limits) ? root.additional_rate_limits : [];
-    const secondary = innerWindow(container, 'secondary_window', 'secondary')
-        ?? innerWindow(limitContainer(additional.find((entry) => {
-            const name = String(entry?.limit_name ?? entry?.metered_feature ?? entry?.id ?? '').toLowerCase();
-            return !name.includes('session');
-        })), 'primary_window', 'primary');
-    if (secondary)
-        quotas.blocking = toQuota(secondary);
-    return quotas;
-}
-export function parseCodexUsage(body, now = new Date()) {
-    const root = (body && typeof body === 'object' ? body : {});
-    return {
-        plan: typeof root.plan_type === 'string' ? root.plan_type : 'unknown',
-        limitReached: limitContainer(root.rate_limit)?.limit_reached === true,
-        resetCredits: Math.max(0, numberOr(root.rate_limit_reset_credits?.available_count, 0)),
-        quotas: readCodexQuotas(root),
-        fetchedAt: now.toISOString(),
-    };
-}
-function timeout(ms) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), ms);
-    return { signal: controller.signal, cancel: () => clearTimeout(timer) };
-}
-function credentialHeaders(accessToken, accountId, extra = {}) {
-    return {
-        accept: 'application/json',
-        authorization: `Bearer ${accessToken}`,
-        'openai-beta': 'codex-1',
-        originator: 'codex_cli_rs',
-        'user-agent': UA,
-        ...(accountId ? { 'chatgpt-account-id': accountId } : {}),
-        ...extra,
-    };
-}
-/** Reads the 5h/blocking windows for one account. Throws on transport/auth failure. */
-export async function fetchCodexUsage(accessToken, accountId, timeoutMs = 15_000) {
-    const ctl = timeout(timeoutMs);
-    try {
-        const response = await fetch(USAGE_URL, { headers: credentialHeaders(accessToken, accountId), signal: ctl.signal });
-        if (!response.ok)
-            throw Object.assign(new Error(`Codex usage API returned HTTP ${response.status}`), { status: response.status });
-        return parseCodexUsage(await response.json());
-    }
-    finally {
-        ctl.cancel();
-    }
-}
-export async function fetchCodexResetCredits(accessToken, accountId, timeoutMs = 15_000) {
-    const ctl = timeout(timeoutMs);
-    try {
-        const response = await fetch(RESET_CREDITS_URL, { headers: credentialHeaders(accessToken, accountId), signal: ctl.signal });
-        const body = await response.json().catch(() => null);
-        if (!response.ok)
-            throw Object.assign(new Error('Codex reset credits API unavailable'), { status: response.status });
-        return {
-            availableCount: Math.max(0, numberOr(body?.available_count ?? body?.availableCount, 0)),
-            credits: (Array.isArray(body?.credits) ? body.credits : []).map((credit) => {
-                const entry = credit;
-                return { status: String(entry?.status ?? 'unknown'), grantedAt: isoOrNull(entry?.granted_at ?? entry?.grantedAt), expiresAt: isoOrNull(entry?.expires_at ?? entry?.expiresAt) };
-            }),
-        };
-    }
-    finally {
-        ctl.cancel();
-    }
-}
-/** Spends one weekly reset credit to restart the 5h window immediately. */
-export async function consumeCodexResetCredit(accessToken, accountId, timeoutMs = 20_000) {
-    const ctl = timeout(timeoutMs);
-    try {
-        const response = await fetch(RESET_CREDITS_CONSUME_URL, {
-            method: 'POST',
-            headers: credentialHeaders(accessToken, accountId, { 'content-type': 'application/json' }),
-            body: JSON.stringify({ redeem_request_id: crypto.randomUUID() }),
-            signal: ctl.signal,
-        });
-        const body = await response.json().catch(() => null);
-        const code = typeof body?.code === 'string' ? body.code : null;
-        const windowsReset = numberOr(body?.windows_reset, 0);
-        if (!response.ok)
-            throw Object.assign(new Error(response.status === 409 ? 'No Codex reset credits available' : `Codex reset credit failed (HTTP ${response.status})`), { status: response.status });
-        return { ok: code === 'reset' || windowsReset > 0, noCredit: code === 'no_credit', code, windowsReset, message: typeof body?.message === 'string' ? body.message : null };
-    }
-    finally {
-        ctl.cancel();
-    }
-}
-/**
- * Sends the tiny streaming request that opens the next 5-hour window.
- * Codex only starts the window after the stream completes, so the body is drained.
- */
-export async function pingCodexAccount(cfg, model = CODEX_PING.model) {
-    const ctl = timeout(cfg.totalTimeoutMs);
-    try {
-        const response = await fetch(codexRequest(cfg, '/responses'), {
-            method: 'POST',
-            headers: codexHeaders(cfg, 'text/event-stream'),
-            body: JSON.stringify({
-                model,
-                input: [{ type: 'message', role: 'user', content: [{ type: 'input_text', text: CODEX_PING.text }] }],
-                instructions: CODEX_PING.instructions,
-                reasoning: { effort: 'none', summary: 'auto' },
-                store: false,
-                stream: true,
-            }),
-            signal: ctl.signal,
-        });
-        if (!response.ok) {
-            await response.body?.cancel?.().catch(() => undefined);
-            return false;
-        }
-        const reader = response.body?.getReader();
-        if (!reader)
-            return true;
-        try {
-            for (;;) {
-                const { done } = await reader.read();
-                if (done)
-                    break;
-            }
-        }
-        finally {
-            reader.releaseLock();
-        }
-        return true;
-    }
-    finally {
-        ctl.cancel();
-    }
-}

package/dist/server/providers/codex.js

@@ -1,186 +0,0 @@
-import { withCodexCredentials, refreshCodexAccount } from './codex-refresh.js';
-const base = (url) => url.replace(/\/$/, '');
-/**
- * Reported Codex CLI client version. The models endpoint rejects requests without it:
- * `400 [{'loc': ('query', 'client_version'), 'msg': 'Field required'}]`.
- */
-export const CODEX_CLIENT_VERSION = '0.144.6';
-export function codexRequest(cfg, path) {
-    return `${base(cfg.baseUrl)}/backend-api/codex${path.startsWith('/') ? path : `/${path}`}`;
-}
-export function codexHeaders(cfg, accept = 'application/json') {
-    if (!cfg.accessToken)
-        throw new Error('Codex credentials were not acquired');
-    return {
-        'content-type': 'application/json', accept,
-        authorization: `Bearer ${cfg.accessToken}`,
-        'chatgpt-account-id': cfg.accountId,
-        originator: 'codex_cli_rs',
-        'openai-beta': 'responses=experimental',
-        ...cfg.customHeaders,
-    };
-}
-function timeout(ms) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), ms);
-    return { signal: controller.signal, cancel: () => clearTimeout(timer) };
-}
-export async function probeCodex(cfg) {
-    const start = Date.now();
-    try {
-        const models = await codexModels(cfg);
-        return { ok: true, detail: 'Connected (200)', latencyMs: Date.now() - start, modelCount: models.length };
-    }
-    catch (error) {
-        return { ok: false, detail: error instanceof Error ? error.message : 'Codex upstream unavailable', latencyMs: Date.now() - start };
-    }
-}
-export async function codexModels(cfg) {
-    const ctl = timeout(cfg.totalTimeoutMs);
-    try {
-        const response = await fetch(`${codexRequest(cfg, '/models')}?client_version=${CODEX_CLIENT_VERSION}`, { headers: codexHeaders(cfg), signal: ctl.signal });
-        // status is required: withCodexCredentials keys its one-shot refresh-and-retry off it.
-        if (!response.ok)
-            throw Object.assign(new Error(`Provider returned HTTP ${response.status}`), { status: response.status });
-        const body = await response.json();
-        const entries = Array.isArray(body) ? body : body.models ?? [];
-        // Upstream identifies models by `slug`; other deployments may use id/model/name.
-        return entries.flatMap((entry) => {
-            const id = [entry.slug, entry.id, entry.model, entry.name].find((value) => typeof value === 'string' && value.length > 0);
-            if (!id)
-                return [];
-            return [{
-                    upstreamId: id,
-                    displayName: entry.display_name ?? entry.displayName ?? entry.name ?? id,
-                    capabilities: { responses: true, streaming: true, reasoning: true },
-                }];
-        });
-    }
-    finally {
-        ctl.cancel();
-    }
-}
-export function codexRequestPayload(req, targetModel = req.model) {
-    const input = req.messages.map((message) => ({ role: message.role, content: message.content.map((block) => {
-            if (block.type === 'text')
-                return { type: 'input_text', text: block.text ?? '' };
-            if (block.type === 'image' && (block.image?.url || block.image?.base64))
-                return { type: 'input_image', image_url: block.image?.url ?? `data:${block.image?.mimeType ?? 'image/png'};base64,${block.image?.base64}` };
-            return null;
-        }).filter(Boolean) }));
-    const payload = { model: targetModel, input, stream: req.stream };
-    if (req.system)
-        payload.instructions = req.system;
-    if (req.maxOutputTokens !== undefined)
-        payload.max_output_tokens = req.maxOutputTokens;
-    if (req.tools?.length)
-        payload.tools = req.tools.map((tool) => ({ type: 'function', name: tool.name, description: tool.description, parameters: tool.inputSchema }));
-    if (req.reasoning?.effort)
-        payload.reasoning = { effort: req.reasoning.effort };
-    return payload;
-}
-function usage(value) {
-    const u = (value && typeof value === 'object' ? value : {});
-    const input = typeof u.input_tokens === 'number' ? u.input_tokens : 0;
-    const output = typeof u.output_tokens === 'number' ? u.output_tokens : 0;
-    return { input, output, total: input + output, cacheRead: typeof u.cached_input_tokens === 'number' ? u.cached_input_tokens : 0, cacheWrite: 0, reasoning: typeof u.reasoning_tokens === 'number' ? u.reasoning_tokens : 0 };
-}
-export function codexResponseToCanonical(body, requestedModel) {
-    let text = '';
-    const tools = [];
-    const output = Array.isArray(body.output) ? body.output : [];
-    for (const item of output) {
-        if (!item || typeof item !== 'object')
-            continue;
-        const value = item;
-        const content = Array.isArray(value.content) ? value.content : [];
-        for (const block of content)
-            if (block && typeof block === 'object' && block.type === 'output_text')
-                text += String(block.text ?? '');
-        if (value.type === 'function_call')
-            tools.push({ id: String(value.call_id ?? value.id ?? ''), name: String(value.name ?? ''), input: value.arguments ?? {} });
-    }
-    const u = usage(body.usage);
-    return { model: requestedModel, text, toolCalls: tools, finishReason: typeof body.status === 'string' ? body.status : null, usage: u };
-}
-export function codexStreamEventToCanonical(event) {
-    if (event.type === 'response.output_text.delta')
-        return { text: typeof event.delta === 'string' ? event.delta : '', isLast: false };
-    if (event.type === 'response.completed') {
-        const response = event.response && typeof event.response === 'object' ? event.response : {};
-        return { text: '', isLast: true, usage: usage(response.usage), finishReason: typeof response.status === 'string' ? response.status : null };
-    }
-    return { text: '', isLast: false };
-}
-async function responseError(response) {
-    const error = Object.assign(new Error(`Codex upstream HTTP ${response.status}`), { status: response.status });
-    return error;
-}
-export async function callCodexNonStreaming(cfg, req) {
-    const call = async (tokenCfg) => {
-        const ctl = timeout(tokenCfg.totalTimeoutMs);
-        try {
-            const response = await fetch(codexRequest(tokenCfg, '/responses'), { method: 'POST', headers: codexHeaders(tokenCfg), body: JSON.stringify(codexRequestPayload(req)), signal: ctl.signal });
-            if (!response.ok)
-                throw await responseError(response);
-            return { ...codexResponseToCanonical(await response.json(), req.model), status: response.status, upstreamRequestId: response.headers.get('x-request-id') };
-        }
-        finally {
-            ctl.cancel();
-        }
-    };
-    if (cfg.accountRecordId)
-        return withCodexCredentials(cfg.accountRecordId, (credentials) => call({ ...cfg, accessToken: credentials.accessToken }));
-    return call(cfg);
-}
-export async function callCodexStreaming(cfg, req, onEvent) {
-    const run = async (tokenCfg) => {
-        const ctl = timeout(tokenCfg.totalTimeoutMs);
-        try {
-            const response = await fetch(codexRequest(tokenCfg, '/responses'), { method: 'POST', headers: codexHeaders(tokenCfg, 'text/event-stream'), body: JSON.stringify(codexRequestPayload(req)), signal: ctl.signal });
-            if (!response.ok || !response.body)
-                throw await responseError(response);
-            const reader = response.body.getReader();
-            const decoder = new TextDecoder();
-            let buffer = '';
-            const process = (raw) => { const data = raw.split(/\r?\n/).find((line) => line.startsWith('data:'))?.slice(5).trim(); if (data && data !== '[DONE]')
-                onEvent(codexStreamEventToCanonical(JSON.parse(data))); };
-            for (;;) {
-                const part = await reader.read();
-                buffer += decoder.decode(part.value ?? new Uint8Array(), { stream: part.done });
-                let index;
-                while ((index = buffer.search(/\r?\n\r?\n/)) >= 0) {
-                    process(buffer.slice(0, index));
-                    buffer = buffer.slice(index + (buffer[index] === '\r' ? 4 : 2));
-                }
-                if (part.done)
-                    break;
-            }
-            if (buffer.trim())
-                process(buffer.replace(/\r?\n$/, ''));
-            return { status: response.status, upstreamRequestId: response.headers.get('x-request-id') };
-        }
-        finally {
-            ctl.cancel();
-        }
-    };
-    if (cfg.accountRecordId)
-        return withCodexCredentials(cfg.accountRecordId, (credentials) => run({ ...cfg, accessToken: credentials.accessToken }));
-    return run(cfg);
-}
-/* eslint-disable preserve-caught-error -- safe refresh failure intentionally omits credentials */
-export async function withCodexUpstream(accountId, refresh, call) {
-    try {
-        return await call();
-    }
-    catch (error) {
-        if (!error || typeof error !== 'object' || ![401, 403].includes(error.status))
-            throw error;
-        const result = await refresh();
-        if (!result.ok)
-            throw new Error('Codex credential refresh failed', { cause: new Error('refresh_failed') });
-        return call();
-    }
-}
-/* eslint-enable preserve-caught-error */
-export { refreshCodexAccount, withCodexCredentials };