@askalf/dario 5.5.83 → 5.5.85

package/dist/codex-backend.js

@@ -0,0 +1,455 @@
+export const CODEX_BACKEND_BASE_URL = process.env.DARIO_CODEX_BASE_URL || 'https://chatgpt.com/backend-api/codex';
+/** Originator string the codex CLI identifies itself with. */
+const CODEX_ORIGINATOR = 'codex_cli_rs';
+/**
+ * Client version sent on the model-discovery call. The backend REQUIRES the
+ * `client_version` query parameter and rejects the request without it; the
+ * value tracks a released codex CLI. Bump it when the backend starts gating on
+ * a newer one — it is a constant precisely so that stays a one-line change.
+ */
+export const CODEX_CLIENT_VERSION = process.env.DARIO_CODEX_CLIENT_VERSION || '0.152.0';
+/**
+ * Which models a subscription may use is decided by the backend, not by us, and
+ * the set moves (it is per-account, and changes as new slugs ship). Hardcoded
+ * name patterns do not work: `gpt-5-codex`, `codex-*`, `gpt-5`, `gpt-5.1`, `o3`
+ * and `gpt-4.1` all 400 with "The '<model>' model is not supported when using
+ * Codex with a <plan> account". So the routable set is DISCOVERED — GET
+ * `${base}/models?client_version=…` with the account's own headers, keeping the
+ * entries the backend marks visible.
+ *
+ * Cached per process because it gates routing on every request; a stale entry
+ * costs at most one upstream 400, and the TTL is short.
+ */
+const MODEL_CACHE_TTL_MS = 10 * 60 * 1000;
+/** Failures cache too, briefly, so an outage isn't one fetch per request. */
+const MODEL_CACHE_ERROR_TTL_MS = 60 * 1000;
+const modelCache = new Map();
+/** Test seam — drop the discovery cache. */
+export function clearCodexModelCache() {
+    modelCache.clear();
+}
+/**
+ * Slugs the backend lists for this account. `visibility` separates models meant
+ * for a picker ("list") from internal ones ("hide" — e.g. `gpt-reserve`,
+ * `codex-auto-review`); only listed ones are routable and advertisable.
+ * Throws on a non-2xx or unparseable response; getCodexModelSlugs absorbs it.
+ */
+export async function fetchCodexModels(creds, fetchImpl = fetch) {
+    const base = CODEX_BACKEND_BASE_URL.replace(/\/$/, '');
+    const target = `${base}/models?client_version=${encodeURIComponent(CODEX_CLIENT_VERSION)}`;
+    const headers = buildCodexHeaders(creds);
+    // Discovery is JSON, not SSE — the shared header builder asks for a stream.
+    headers['Accept'] = 'application/json';
+    const res = await fetchImpl(target, { method: 'GET', headers });
+    if (!res.ok)
+        throw new Error(`codex /models ${res.status}`);
+    const parsed = (await res.json());
+    const entries = parsed.models ?? parsed.data ?? [];
+    const slugs = [];
+    for (const m of entries) {
+        const slug = m?.slug ?? m?.id;
+        if (typeof slug !== 'string' || slug.length === 0)
+            continue;
+        // Absent visibility counts as listed: a backend that stops sending the
+        // field should degrade to "offer everything", not to "offer nothing".
+        if (m.visibility != null && m.visibility !== 'list')
+            continue;
+        slugs.push(slug);
+    }
+    return slugs;
+}
+/**
+ * Cached {@link fetchCodexModels}, keyed by account alias. Never throws — an
+ * unreachable backend yields the last known set, or an empty one, which means
+ * "route nothing here by name". An explicit `codex:`/`chatgpt:` prefix still
+ * routes, so discovery being down never makes the engine unusable.
+ */
+export async function getCodexModelSlugs(creds, fetchImpl = fetch) {
+    const hit = modelCache.get(creds.alias);
+    if (hit && Date.now() - hit.fetchedAt < hit.ttlMs)
+        return hit.slugs;
+    try {
+        const slugs = await fetchCodexModels(creds, fetchImpl);
+        modelCache.set(creds.alias, { slugs, fetchedAt: Date.now(), ttlMs: MODEL_CACHE_TTL_MS });
+        return slugs;
+    }
+    catch {
+        const slugs = hit?.slugs ?? [];
+        modelCache.set(creds.alias, { slugs, fetchedAt: Date.now(), ttlMs: MODEL_CACHE_ERROR_TTL_MS });
+        return slugs;
+    }
+}
+/**
+ * Whether a request naming `model` should be served from the subscription: the
+ * name matches a discovered slug. Pure, with the slugs injected, so routing is
+ * testable without network — and checked BEFORE openai-backend's
+ * `isOpenAIModel` (the codex adapter has the higher priority), so a discovered
+ * `gpt-5.5` reaches the subscription while a plain `gpt-4o` still reaches a
+ * configured API-key backend.
+ */
+export function isCodexModel(model, slugs) {
+    if (!model)
+        return false;
+    const m = model.toLowerCase();
+    return slugs.some(s => s.toLowerCase() === m);
+}
+/**
+ * Pull `chatgpt_account_id` out of the id_token's `https://api.openai.com/auth`
+ * claim. Payload only — this is reading our own token for a routing header, not
+ * validating a token, so there's nothing to verify a signature against here.
+ * Null when the token is absent/malformed/claimless; the caller then omits the
+ * header, which is what the CLI does for accounts without a workspace.
+ */
+export function extractChatGPTAccountId(idToken) {
+    if (!idToken)
+        return null;
+    const parts = idToken.split('.');
+    if (parts.length < 2)
+        return null;
+    try {
+        const payload = JSON.parse(Buffer.from(parts[1], 'base64url').toString('utf-8'));
+        const auth = payload['https://api.openai.com/auth'];
+        const id = auth?.chatgpt_account_id;
+        return typeof id === 'string' && id.length > 0 ? id : null;
+    }
+    catch {
+        return null;
+    }
+}
+function messageContentToText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map(part => {
+            const p = part;
+            return typeof p?.text === 'string' ? p.text : '';
+        })
+            .join('');
+    }
+    return content == null ? '' : JSON.stringify(content);
+}
+/**
+ * Translate an OpenAI chat/completions request body into a Responses request.
+ *
+ * - system messages collapse into `instructions` (Responses has no system role)
+ * - assistant `tool_calls` become `function_call` items, `role: "tool"` replies
+ *   become `function_call_output` items, keyed by the same call_id
+ * - tools lose the `{type:'function', function:{…}}` nesting; Responses takes
+ *   name/description/parameters flat on the tool
+ * - `store: false` because dario is a proxy: nothing here is a ChatGPT thread
+ *   the user would expect to find in their history
+ */
+export function chatCompletionsToResponses(body) {
+    const messages = body.messages ?? [];
+    const instructions = messages
+        .filter(m => m.role === 'system' || m.role === 'developer')
+        .map(m => messageContentToText(m.content))
+        .filter(t => t.length > 0)
+        .join('\n\n');
+    const input = [];
+    for (const m of messages) {
+        if (m.role === 'system' || m.role === 'developer')
+            continue;
+        if (m.role === 'tool') {
+            input.push({
+                type: 'function_call_output',
+                call_id: m.tool_call_id ?? '',
+                output: messageContentToText(m.content),
+            });
+            continue;
+        }
+        if (m.role === 'assistant') {
+            const text = messageContentToText(m.content);
+            if (text.length > 0) {
+                input.push({ role: 'assistant', content: [{ type: 'output_text', text }] });
+            }
+            const calls = m.tool_calls;
+            for (const c of calls ?? []) {
+                input.push({
+                    type: 'function_call',
+                    call_id: c.id ?? '',
+                    name: c.function?.name ?? '',
+                    arguments: c.function?.arguments ?? '{}',
+                });
+            }
+            continue;
+        }
+        input.push({ role: 'user', content: [{ type: 'input_text', text: messageContentToText(m.content) }] });
+    }
+    const out = {
+        model: String(body.model ?? ''),
+        input,
+        store: false,
+        stream: true,
+    };
+    if (instructions.length > 0)
+        out.instructions = instructions;
+    const tools = body.tools;
+    if (Array.isArray(tools) && tools.length > 0) {
+        out.tools = tools.map(t => ({
+            type: 'function',
+            name: t.function?.name ?? '',
+            description: t.function?.description,
+            parameters: t.function?.parameters ?? { type: 'object', properties: {} },
+        }));
+    }
+    if (body.tool_choice != null)
+        out.tool_choice = body.tool_choice;
+    if (body.temperature != null)
+        out.temperature = body.temperature;
+    if (body.top_p != null)
+        out.top_p = body.top_p;
+    if (body.max_tokens != null || body.max_completion_tokens != null) {
+        out.max_output_tokens = body.max_completion_tokens ?? body.max_tokens;
+    }
+    if (body.reasoning_effort != null)
+        out.reasoning = { effort: body.reasoning_effort };
+    return out;
+}
+/**
+ * Stateful per-request translator: Responses SSE in, chat/completions out.
+ *
+ * `chunk()` returns the chat.completion.chunk SSE line to write back (null when
+ * the upstream event has no chat-shape equivalent — reasoning summaries,
+ * progress events). It also accumulates, so `complete()` can hand back a single
+ * non-streaming `chat.completion` body. dario always asks the Codex backend for
+ * a stream and collapses it here when the client didn't want one; that keeps one
+ * upstream code path instead of two.
+ *
+ * One translator per request — never module-global — for the same reason
+ * createOpenAIStreamTranslator is per-call (#642-audit: interleaved streams
+ * corrupting shared tool-call indices).
+ */
+export function createResponsesTranslator(model) {
+    const created = Math.floor(Date.now() / 1000);
+    let id = 'chatcmpl-dario';
+    let text = '';
+    let usage = null;
+    const toolCalls = new Map();
+    let nextToolIndex = 0;
+    const frame = (delta, finish) => `data: ${JSON.stringify({
+        id,
+        object: 'chat.completion.chunk',
+        created,
+        model,
+        choices: [{ index: 0, delta, finish_reason: finish }],
+    })}\n\n`;
+    return {
+        /** Feed one raw SSE line. Returns the line to forward, or null. */
+        chunk(line) {
+            if (!line.startsWith('data: '))
+                return null;
+            const raw = line.slice(6).trim();
+            if (!raw || raw === '[DONE]')
+                return null;
+            let e;
+            try {
+                e = JSON.parse(raw);
+            }
+            catch {
+                return null;
+            }
+            const type = String(e.type ?? '');
+            if (type === 'response.created') {
+                const r = e.response;
+                if (r?.id)
+                    id = `chatcmpl-${r.id.replace(/^resp_/, '')}`;
+                return null;
+            }
+            if (type === 'response.output_text.delta') {
+                const d = typeof e.delta === 'string' ? e.delta : '';
+                if (!d)
+                    return null;
+                text += d;
+                return frame({ content: d }, null);
+            }
+            if (type === 'response.output_item.added') {
+                const item = e.item;
+                if (item?.type !== 'function_call')
+                    return null;
+                const key = item.id ?? item.call_id ?? `item_${nextToolIndex}`;
+                const acc = {
+                    index: nextToolIndex++,
+                    id: item.call_id ?? key,
+                    name: item.name ?? '',
+                    args: '',
+                };
+                toolCalls.set(key, acc);
+                return frame({ tool_calls: [{ index: acc.index, id: acc.id, type: 'function', function: { name: acc.name, arguments: '' } }] }, null);
+            }
+            if (type === 'response.function_call_arguments.delta') {
+                const key = String(e.item_id ?? '');
+                const acc = toolCalls.get(key) ?? [...toolCalls.values()].at(-1);
+                const d = typeof e.delta === 'string' ? e.delta : '';
+                if (!acc || !d)
+                    return null;
+                acc.args += d;
+                return frame({ tool_calls: [{ index: acc.index, function: { arguments: d } }] }, null);
+            }
+            if (type === 'response.completed' || type === 'response.incomplete') {
+                const r = e.response;
+                const u = r?.usage;
+                if (u) {
+                    usage = {
+                        prompt_tokens: u.input_tokens ?? 0,
+                        completion_tokens: u.output_tokens ?? 0,
+                        total_tokens: (u.input_tokens ?? 0) + (u.output_tokens ?? 0),
+                    };
+                }
+                return `${frame({}, toolCalls.size > 0 ? 'tool_calls' : 'stop')}data: [DONE]\n\n`;
+            }
+            return null;
+        },
+        /** Everything seen so far, as one non-streaming chat.completion body. */
+        complete() {
+            const calls = [...toolCalls.values()].sort((a, b) => a.index - b.index);
+            const message = { role: 'assistant', content: text || null };
+            if (calls.length > 0) {
+                message.tool_calls = calls.map(c => ({
+                    id: c.id,
+                    type: 'function',
+                    function: { name: c.name, arguments: c.args },
+                }));
+            }
+            return {
+                id,
+                object: 'chat.completion',
+                created,
+                model,
+                choices: [{ index: 0, message, finish_reason: calls.length > 0 ? 'tool_calls' : 'stop' }],
+                usage: usage ?? { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+            };
+        },
+    };
+}
+export function buildCodexHeaders(creds) {
+    const headers = {
+        'Content-Type': 'application/json',
+        'Accept': 'text/event-stream',
+        'Authorization': `Bearer ${creds.accessToken}`,
+        'originator': CODEX_ORIGINATOR,
+        'OpenAI-Beta': 'responses=experimental',
+    };
+    const accountId = extractChatGPTAccountId(creds.idToken);
+    if (accountId)
+        headers['ChatGPT-Account-ID'] = accountId;
+    return headers;
+}
+/**
+ * Serve a /v1/chat/completions request from a stored Codex account.
+ *
+ * `fetchImpl` is injectable so the translation and header construction are
+ * testable without network (test/codex-backend.mjs), matching the pattern
+ * test/codex-oauth.mjs already uses.
+ */
+export async function forwardToCodex(req, res, body, creds, corsOrigin, securityHeaders, upstreamTimeoutMs, verbose, fetchImpl = fetch) {
+    void req;
+    let parsed;
+    try {
+        parsed = JSON.parse(body.toString());
+    }
+    catch {
+        res.writeHead(400, { 'Content-Type': 'application/json', ...securityHeaders });
+        res.end(JSON.stringify({ error: 'Codex backend requires a JSON chat/completions body' }));
+        return;
+    }
+    const clientWantsStream = parsed.stream === true;
+    const model = String(parsed.model ?? '');
+    const upstreamBody = chatCompletionsToResponses(parsed);
+    const target = `${CODEX_BACKEND_BASE_URL.replace(/\/$/, '')}/responses`;
+    const abort = new AbortController();
+    const timeout = setTimeout(() => abort.abort(), upstreamTimeoutMs);
+    try {
+        if (verbose)
+            console.log(`[dario] → codex backend: ${target} (model: ${model})`);
+        const upstream = await fetchImpl(target, {
+            method: 'POST',
+            headers: buildCodexHeaders(creds),
+            body: JSON.stringify(upstreamBody),
+            signal: abort.signal,
+        });
+        if (!upstream.ok) {
+            const detail = await upstream.text().catch(() => '');
+            if (verbose)
+                console.error(`[dario] codex backend ${upstream.status}: ${detail.slice(0, 300)}`);
+            res.writeHead(upstream.status, { 'Content-Type': 'application/json', ...securityHeaders });
+            res.end(JSON.stringify({
+                error: 'Upstream Codex backend error',
+                status: upstream.status,
+                account: creds.alias,
+            }));
+            return;
+        }
+        const translator = createResponsesTranslator(model);
+        if (clientWantsStream) {
+            res.writeHead(200, {
+                'Content-Type': 'text/event-stream',
+                'Cache-Control': 'no-cache',
+                'Connection': 'keep-alive',
+                'Access-Control-Allow-Origin': corsOrigin,
+                ...securityHeaders,
+            });
+        }
+        let buffered = '';
+        if (upstream.body) {
+            const reader = upstream.body.getReader();
+            const decoder = new TextDecoder();
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffered += decoder.decode(value, { stream: true });
+                    // SSE frames are newline-delimited; keep the trailing partial line.
+                    const lines = buffered.split('\n');
+                    buffered = lines.pop() ?? '';
+                    for (const line of lines) {
+                        const out = translator.chunk(line);
+                        if (out && clientWantsStream)
+                            res.write(out);
+                    }
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+            if (buffered.length > 0) {
+                const out = translator.chunk(buffered);
+                if (out && clientWantsStream)
+                    res.write(out);
+            }
+        }
+        if (clientWantsStream) {
+            res.end();
+        }
+        else {
+            res.writeHead(200, {
+                'Content-Type': 'application/json',
+                'Access-Control-Allow-Origin': corsOrigin,
+                ...securityHeaders,
+            });
+            res.end(JSON.stringify(translator.complete()));
+        }
+    }
+    catch (err) {
+        // Detail stays server-side (CodeQL js/stack-trace-exposure), same as
+        // forwardToOpenAI.
+        const detail = err instanceof Error ? err.message : String(err);
+        if (verbose)
+            console.error(`[dario] codex backend (${creds.alias}) error: ${detail}`);
+        if (!res.headersSent) {
+            res.writeHead(502, { 'Content-Type': 'application/json', ...securityHeaders });
+            res.end(JSON.stringify({ error: 'Upstream Codex backend error', account: creds.alias }));
+        }
+        else {
+            try {
+                res.end();
+            }
+            catch { /* already closed */ }
+        }
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}

package/dist/codex-oauth.d.ts

@@ -0,0 +1,31 @@
+export declare const CODEX_CLIENT_ID: string;
+export declare const CODEX_AUTHORIZE_URL: string;
+export declare const CODEX_TOKEN_URL: string;
+export declare const CODEX_REDIRECT_URI: string;
+export declare const CODEX_SCOPE = "openid profile email offline_access";
+export interface CodexTokens {
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: number;
+    idToken?: string;
+}
+export declare function generateCodexPKCE(): {
+    codeVerifier: string;
+    codeChallenge: string;
+};
+/**
+ * Build the authorize URL for a manual-paste login flow (same shape as
+ * accounts.ts's startAddAccount — dario has no localhost callback server
+ * running by default, so the manual copy-paste flow is the primary path,
+ * not a fallback).
+ */
+export declare function buildCodexAuthorizeUrl(codeChallenge: string, state: string): string;
+export declare function exchangeCodexAuthorizationCode(code: string, codeVerifier: string): Promise<CodexTokens>;
+/**
+ * Refresh a Codex access token. Deliberately NOT wrapped in any
+ * single-flight/lock machinery yet — that's exactly the thing
+ * test/manual/codex-refresh-race.mjs exists to determine the need for.
+ * Adding pool/lock complexity before that answer is known would be
+ * guessing at a solution to an unconfirmed problem.
+ */
+export declare function refreshCodexAccessToken(refreshToken: string): Promise<CodexTokens>;

package/dist/codex-oauth.js

@@ -0,0 +1,114 @@
+/**
+ * Codex OAuth primitives — the "altman" engine (dario#1009).
+ *
+ * A deliberately separate, standalone module from oauth.ts/accounts.ts,
+ * not a generalization of them. Two providers isn't enough to know what a
+ * good shared abstraction looks like yet; forcing one now would mean
+ * guessing at the shape from a single example. See the dario#993/#1009
+ * scoping discussion for the reasoning.
+ *
+ * Unlike Claude's OAuth config (auto-detected from the installed CC binary
+ * — see cc-oauth-detect.ts — because Anthropic rotates client_id/URLs
+ * between CC releases), Codex's values below are stable, publicly known
+ * constants used by OpenAI's own `codex` CLI. Hardcoded here the same way
+ * every other OSS OAuth client for this flow does (e.g.
+ * numman-ali/opencode-openai-codex-auth), with an env override escape
+ * hatch in case that changes.
+ *
+ * THE OPEN QUESTION THIS MODULE EXISTS TO ANSWER (see
+ * test/manual/codex-refresh-race.mjs): does OpenAI invalidate the previous
+ * refresh_token on every refresh, the way Anthropic does? That single fact
+ * determines whether Codex needs pool/lock machinery at all, or something
+ * much simpler. Not yet known — no public source documents it, because
+ * every existing OAuth client for this flow (this codebase's own
+ * inspiration included) is single-instance, single-user, and has never
+ * had a reason to race two refreshes against the same token.
+ */
+import { randomBytes, createHash } from 'node:crypto';
+// OAuth constants — from OpenAI's own `codex` CLI, reused unmodified by
+// every third-party client for this flow (Cline, opencode's codex-auth
+// plugin). Not dario-specific; not secret.
+export const CODEX_CLIENT_ID = process.env.DARIO_CODEX_CLIENT_ID || 'app_EMoamEEZ73f0CkXaXp7hrann';
+export const CODEX_AUTHORIZE_URL = process.env.DARIO_CODEX_AUTHORIZE_URL || 'https://auth.openai.com/oauth/authorize';
+export const CODEX_TOKEN_URL = process.env.DARIO_CODEX_TOKEN_URL || 'https://auth.openai.com/oauth/token';
+export const CODEX_REDIRECT_URI = process.env.DARIO_CODEX_REDIRECT_URI || 'http://localhost:1455/auth/callback';
+export const CODEX_SCOPE = 'openid profile email offline_access';
+function base64url(buf) {
+    return buf.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+export function generateCodexPKCE() {
+    const codeVerifier = base64url(randomBytes(32));
+    const codeChallenge = base64url(createHash('sha256').update(codeVerifier).digest());
+    return { codeVerifier, codeChallenge };
+}
+/**
+ * Build the authorize URL for a manual-paste login flow (same shape as
+ * accounts.ts's startAddAccount — dario has no localhost callback server
+ * running by default, so the manual copy-paste flow is the primary path,
+ * not a fallback).
+ */
+export function buildCodexAuthorizeUrl(codeChallenge, state) {
+    const url = new URL(CODEX_AUTHORIZE_URL);
+    url.searchParams.set('response_type', 'code');
+    url.searchParams.set('client_id', CODEX_CLIENT_ID);
+    url.searchParams.set('redirect_uri', CODEX_REDIRECT_URI);
+    url.searchParams.set('scope', CODEX_SCOPE);
+    url.searchParams.set('code_challenge', codeChallenge);
+    url.searchParams.set('code_challenge_method', 'S256');
+    url.searchParams.set('state', state);
+    return url.toString();
+}
+function parseTokenResponse(json) {
+    if (!json?.access_token || !json?.refresh_token || typeof json?.expires_in !== 'number') {
+        throw new Error(`Codex token response missing required fields: ${JSON.stringify(Object.keys(json ?? {}))}`);
+    }
+    return {
+        accessToken: json.access_token,
+        refreshToken: json.refresh_token,
+        expiresAt: Date.now() + json.expires_in * 1000,
+        idToken: json.id_token,
+    };
+}
+export async function exchangeCodexAuthorizationCode(code, codeVerifier) {
+    const res = await fetch(CODEX_TOKEN_URL, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body: new URLSearchParams({
+            grant_type: 'authorization_code',
+            client_id: CODEX_CLIENT_ID,
+            code,
+            code_verifier: codeVerifier,
+            redirect_uri: CODEX_REDIRECT_URI,
+        }),
+        signal: AbortSignal.timeout(30_000),
+    });
+    if (!res.ok) {
+        const body = await res.text().catch(() => '');
+        throw new Error(`Codex code->token exchange failed (${res.status}): ${body.slice(0, 200)}`);
+    }
+    return parseTokenResponse(await res.json());
+}
+/**
+ * Refresh a Codex access token. Deliberately NOT wrapped in any
+ * single-flight/lock machinery yet — that's exactly the thing
+ * test/manual/codex-refresh-race.mjs exists to determine the need for.
+ * Adding pool/lock complexity before that answer is known would be
+ * guessing at a solution to an unconfirmed problem.
+ */
+export async function refreshCodexAccessToken(refreshToken) {
+    const res = await fetch(CODEX_TOKEN_URL, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body: new URLSearchParams({
+            grant_type: 'refresh_token',
+            refresh_token: refreshToken,
+            client_id: CODEX_CLIENT_ID,
+        }),
+        signal: AbortSignal.timeout(30_000),
+    });
+    if (!res.ok) {
+        const body = await res.text().catch(() => '');
+        throw new Error(`Codex token refresh failed (${res.status}): ${body.slice(0, 200)}`);
+    }
+    return parseTokenResponse(await res.json());
+}

package/dist/model-catalog.d.ts

@@ -74,8 +74,15 @@ export declare function resolveFamilyBase(family: string, bases: readonly string
  * absent/ineligible — callers fall back to their static map.
  */
 export declare function resolveAliasAgainst(model: string, bases: readonly string[]): string | null;
-/** OpenAI-shape /v1/models payload for a list of advertised ids. */
-export declare function buildOpenAIModelsList(ids: readonly string[]): {
+/**
+ * OpenAI-shape /v1/models payload for a list of advertised ids.
+ *
+ * `ownedBy` names the ids served by a non-Anthropic backend — the
+ * Codex/ChatGPT-subscription slugs (dario#1137). Everything else stays
+ * `anthropic`: the advertised catalog is Claude's, and a client picking a
+ * model shouldn't have to guess which vendor answers it.
+ */
+export declare function buildOpenAIModelsList(ids: readonly string[], ownedBy?: Readonly<Record<string, string>>): {
     object: string;
     data: Array<{
         id: string;

package/dist/model-catalog.js

@@ -202,11 +202,18 @@ export function resolveAliasAgainst(model, bases) {
     }
     return null;
 }
-/** OpenAI-shape /v1/models payload for a list of advertised ids. */
-export function buildOpenAIModelsList(ids) {
+/**
+ * OpenAI-shape /v1/models payload for a list of advertised ids.
+ *
+ * `ownedBy` names the ids served by a non-Anthropic backend — the
+ * Codex/ChatGPT-subscription slugs (dario#1137). Everything else stays
+ * `anthropic`: the advertised catalog is Claude's, and a client picking a
+ * model shouldn't have to guess which vendor answers it.
+ */
+export function buildOpenAIModelsList(ids, ownedBy = {}) {
     return {
         object: 'list',
-        data: ids.map((id) => ({ id, object: 'model', created: 1700000000, owned_by: 'anthropic' })),
+        data: ids.map((id) => ({ id, object: 'model', created: 1700000000, owned_by: ownedBy[id] ?? 'anthropic' })),
     };
 }
 export const DEFAULT_CATALOG_TTL_MS = 3_600_000; // 1h — model launches are rare