@askalf/dario 6.0.21 → 6.0.22

package/README.md

@@ -18,7 +18,7 @@
 
 <p><strong>One local endpoint. Every AI tool you own. The subscriptions you already pay for.</strong></p>
 
-<sub><code>npm i -g @askalf/dario</code> · <strong>0</strong> runtime deps · <a href="https://www.npmjs.com/package/@askalf/dario">SLSA-attested</a> every release · nothing phones home · ~29k lines you can read in a weekend · independent, unofficial, third-party (<a href="DISCLAIMER.md">DISCLAIMER.md</a>)</sub>
+<sub><code>npm i -g @askalf/dario</code> · <strong>0</strong> runtime deps · <a href="https://www.npmjs.com/package/@askalf/dario">SLSA-attested</a> every release · nothing phones home · ~30k lines you can read in a weekend · independent, unofficial, third-party (<a href="DISCLAIMER.md">DISCLAIMER.md</a>)</sub>
 
 <sub>Part of <a href="#own-your-stack"><strong>Own Your Stack</strong></a> — 12 open tools for owning your AI infra: <a href="https://github.com/askalf/truecopy">truecopy</a> · <a href="https://github.com/askalf/strongroom">strongroom</a> · <a href="https://github.com/askalf/fieldpass">fieldpass</a> · <a href="https://github.com/askalf/plumbline">plumbline</a> · <a href="#own-your-stack">full family ↓</a></sub>
 
@@ -165,6 +165,8 @@ curl localhost:3456/v1/messages -H 'content-type: application/json' \
 
 Streaming, tool calls, and tool-result round trips work on both shapes: dario translates chat/completions **or** Messages into the Responses API the subscription backend speaks, and translates the stream back into `chat.completion.chunk` or Anthropic message events to match what the client asked in. There is no `/v1/responses` inbound yet.
 
+**Chat/completions fidelity:** text and `image_url` user-content parts (HTTPS URLs and data URIs, including the `detail` fidelity setting) carry through to Responses input items. The Codex subscription backend does not accept every chat field, so `response_format`, `stop`, `n`, `logprobs`, `stream_options` and other unmapped chat-only fields are intentionally lossy — and so are the sampling parameters `temperature`, `top_p`, `max_tokens` and `max_completion_tokens`, which translate cleanly but are then rejected by the backend and stripped before the request goes out. With `--verbose`, dario reports each field that does not reach Codex once per process.
+
 Codex accounts live in `~/.dario/codex-accounts/`, entirely separate from the Claude pool. Nothing about `dario login`, `dario accounts`, or Claude routing changes.
 
 ---
@@ -307,7 +309,7 @@ The split isn't live, but it was announced once on short notice and could return
 
 | Signal | Status |
 |---|---|
-| Source | **~29k** lines of TypeScript across **59** files — auditable in a weekend (v5 removed shim; the pool is the one code path) |
+| Source | **~30k** lines of TypeScript across **65** files — auditable in a weekend (v5 removed shim; the pool is the one code path) |
 | Dependencies | **0 runtime.** Verify: `npm ls --production` |
 | Provenance | Every release [SLSA-attested](https://www.npmjs.com/package/@askalf/dario) via GitHub Actions + Sigstore |
 | Scanning | [CodeQL](https://github.com/askalf/dario/actions/workflows/codeql.yml) on every push and weekly |

package/dist/cli.js

@@ -1121,7 +1121,7 @@ async function codex() {
             console.error(`[dario] Codex account "${alias}" already exists. Remove it first with \`dario codex remove ${alias}\`.`);
             process.exit(1);
         }
-        const { authorizeUrl, codeVerifier } = await startAddCodexAccount(alias);
+        const { authorizeUrl, codeVerifier, state } = await startAddCodexAccount(alias);
         console.log('');
         console.log('  Open this URL and log in with your ChatGPT Plus/Pro account.');
         console.log('  The browser will land on a localhost page that does not load —');
@@ -1130,11 +1130,21 @@ async function codex() {
         console.log(`  ${authorizeUrl}`);
         console.log('');
         const pasted = await readLineFromStdin('  Redirect URL (or code): ');
-        const { code } = parseCodexManualPaste(pasted);
+        const { code, state: pastedState } = parseCodexManualPaste(pasted);
         if (!code) {
             console.error('[dario] No code found in what you pasted.');
             process.exit(1);
         }
+        // The state parameter is what ties this paste to the URL printed above.
+        // It was parsed and then discarded, which made the CSRF guard the OAuth
+        // flow carries decorative: a redirect from some other authorize request
+        // would have been accepted and stored. A paste with no state at all (a
+        // bare code — accepted shape #3) can't be checked and is left alone.
+        if (pastedState !== null && pastedState !== state) {
+            console.error('[dario] The pasted redirect does not match this login attempt (state mismatch).');
+            console.error('        Start over with `dario codex add ' + alias + '` and paste the URL from THAT browser tab.');
+            process.exit(1);
+        }
         try {
             await completeAddCodexAccount(alias, code, codeVerifier);
             console.log('');

package/dist/codex-accounts.d.ts

@@ -22,9 +22,43 @@ export declare function startAddCodexAccount(alias: string): Promise<{
 export declare function completeAddCodexAccount(alias: string, code: string, codeVerifier: string): Promise<CodexAccountCredentials>;
 export declare function codexAccountNeedsRefresh(creds: CodexAccountCredentials): boolean;
 export declare function refreshCodexAccount(creds: CodexAccountCredentials): Promise<CodexAccountCredentials>;
+/**
+ * A refresh this process is not going to attempt right now: either the last one
+ * failed inside the cool-down below, or the one just attempted failed. Carries
+ * the alias so the caller can name the CODEX account in the client's error —
+ * the whole point of the fix, since the request otherwise fell through to the
+ * Claude path and got told to run `dario login`.
+ */
+export declare class CodexCredentialsUnavailableError extends Error {
+    readonly alias: string;
+    readonly status: number;
+    readonly failedAt: number;
+    constructor(alias: string, failure: CodexRefreshFailure);
+}
+/** Last refresh rejection remembered for an alias. No token material here. */
+export interface CodexRefreshFailure {
+    /** When the failure was observed (ms epoch). */
+    at: number;
+    /** Upstream HTTP status, or 0 when no response arrived (transport/timeout). */
+    status: number;
+    /** First ~120 chars of the upstream body / error text — never a token. */
+    message: string;
+}
+/** Last remembered refresh failure for an alias, or null. Read-only view for
+ *  the admin surface (`GET /codex`) — never triggers an upstream call. */
+export declare function getCodexRefreshFailure(alias: string): CodexRefreshFailure | null;
+/** Test seam — forget every remembered failure. */
+export declare function _resetCodexRefreshFailuresForTest(): void;
 /**
  * Return credentials guaranteed fresh enough to send upstream, refreshing (once,
  * per alias, per process) when within the expiry buffer.
+ *
+ * Throws {@link CodexCredentialsUnavailableError} when the refresh failed —
+ * including when it failed RECENTLY and this call therefore made no upstream
+ * attempt at all. Callers must treat the throw as "the codex route is not
+ * available for this request" and say so naming the codex account; swallowing
+ * it is what turned a dead token into a per-request token-endpoint storm with
+ * a misleading "run `dario login`" answer to the client.
  */
 export declare function getFreshCodexAccount(creds: CodexAccountCredentials): Promise<CodexAccountCredentials>;
 /**

package/dist/codex-accounts.js

@@ -13,7 +13,7 @@ import { readFile, mkdir, readdir, unlink } from 'node:fs/promises';
 import { join, basename } from 'node:path';
 import { homedir } from 'node:os';
 import { randomBytes } from 'node:crypto';
-import { generateCodexPKCE, buildCodexAuthorizeUrl, exchangeCodexAuthorizationCode, refreshCodexAccessToken, } from './codex-oauth.js';
+import { generateCodexPKCE, buildCodexAuthorizeUrl, exchangeCodexAuthorizationCode, refreshCodexAccessToken, CodexRefreshError, } from './codex-oauth.js';
 import { durableWriteFile } from './durable-write.js';
 const DARIO_DIR = join(homedir(), '.dario');
 const CODEX_ACCOUNTS_DIR = join(DARIO_DIR, 'codex-accounts');
@@ -106,6 +106,7 @@ export async function removeCodexAccount(alias) {
         return false;
     try {
         await unlink(path);
+        refreshFailures.delete(alias);
         return true;
     }
     catch {
@@ -140,6 +141,8 @@ export async function completeAddCodexAccount(alias, code, codeVerifier) {
         idToken: tokens.idToken,
     };
     await saveCodexAccount(creds);
+    // Freshly minted credentials — whatever the old ones failed with is history.
+    refreshFailures.delete(alias);
     return creds;
 }
 /**
@@ -163,6 +166,75 @@ export async function refreshCodexAccount(creds) {
     await saveCodexAccount(updated);
     return updated;
 }
+/**
+ * A refresh this process is not going to attempt right now: either the last one
+ * failed inside the cool-down below, or the one just attempted failed. Carries
+ * the alias so the caller can name the CODEX account in the client's error —
+ * the whole point of the fix, since the request otherwise fell through to the
+ * Claude path and got told to run `dario login`.
+ */
+export class CodexCredentialsUnavailableError extends Error {
+    alias;
+    status;
+    failedAt;
+    constructor(alias, failure) {
+        super(`codex account ${alias}: token refresh failed (${failure.status || 'no response'}): ${failure.message}`);
+        this.name = 'CodexCredentialsUnavailableError';
+        this.alias = alias;
+        this.status = failure.status;
+        this.failedAt = failure.at;
+    }
+}
+/**
+ * A dead refresh_token used to cost one token-endpoint POST PER REQUEST,
+ * forever, silently: getFreshCodexAccount only collapsed CONCURRENT refreshes
+ * and remembered nothing about a failure, so every inbound request re-asked.
+ * Same shape as codex-backend.ts's MODEL_CACHE_ERROR_TTL_MS — remember the
+ * failure briefly, so a broken account costs one attempt a minute and recovers
+ * on its own within a minute of the operator fixing it.
+ */
+const REFRESH_FAILURE_TTL_MS = 60 * 1000;
+const refreshFailures = new Map();
+/** Last remembered refresh failure for an alias, or null. Read-only view for
+ *  the admin surface (`GET /codex`) — never triggers an upstream call. */
+export function getCodexRefreshFailure(alias) {
+    const hit = refreshFailures.get(alias);
+    return hit ? { at: hit.at, status: hit.status, message: hit.message } : null;
+}
+/** Test seam — forget every remembered failure. */
+export function _resetCodexRefreshFailuresForTest() {
+    refreshFailures.clear();
+}
+function noteRefreshFailure(alias, err) {
+    const status = err instanceof CodexRefreshError ? err.status : 0;
+    const raw = err instanceof CodexRefreshError
+        ? err.bodySnippet
+        : (err instanceof Error ? err.message : String(err));
+    const previous = refreshFailures.get(alias);
+    const entry = {
+        at: Date.now(),
+        status,
+        message: raw.slice(0, 120),
+        retryAt: Date.now() + REFRESH_FAILURE_TTL_MS,
+        logged: previous?.logged ?? false,
+    };
+    if (!entry.logged) {
+        // ONE line per outage. The body snippet is the upstream's own error text
+        // (`invalid_grant`, an HTML 502 page, a timeout message) — the tokens
+        // themselves are never logged.
+        console.error(`[dario] codex account ${alias}: token refresh failed (${status || 'no response'}): ${entry.message} — ` +
+            `not retrying for ${Math.round(REFRESH_FAILURE_TTL_MS / 1000)}s. Re-add with \`dario codex add ${alias}\` if this persists.`);
+        entry.logged = true;
+    }
+    refreshFailures.set(alias, entry);
+    return entry;
+}
+function noteRefreshRecovered(alias) {
+    const previous = refreshFailures.get(alias);
+    refreshFailures.delete(alias);
+    if (previous?.logged)
+        console.log(`[dario] codex account ${alias}: token refresh recovered`);
+}
 /**
  * In-process refresh serialization.
  *
@@ -183,14 +255,37 @@ const inflightRefresh = new Map();
 /**
  * Return credentials guaranteed fresh enough to send upstream, refreshing (once,
  * per alias, per process) when within the expiry buffer.
+ *
+ * Throws {@link CodexCredentialsUnavailableError} when the refresh failed —
+ * including when it failed RECENTLY and this call therefore made no upstream
+ * attempt at all. Callers must treat the throw as "the codex route is not
+ * available for this request" and say so naming the codex account; swallowing
+ * it is what turned a dead token into a per-request token-endpoint storm with
+ * a misleading "run `dario login`" answer to the client.
  */
 export async function getFreshCodexAccount(creds) {
-    if (!codexAccountNeedsRefresh(creds))
+    if (!codexAccountNeedsRefresh(creds)) {
+        // Credentials on disk are fresh again — an operator re-added the account,
+        // or another process refreshed it. Nothing to cool down anymore.
+        noteRefreshRecovered(creds.alias);
         return creds;
+    }
     const existing = inflightRefresh.get(creds.alias);
     if (existing)
         return existing;
-    const p = refreshCodexAccount(creds).finally(() => {
+    const remembered = refreshFailures.get(creds.alias);
+    if (remembered && Date.now() < remembered.retryAt) {
+        throw new CodexCredentialsUnavailableError(creds.alias, remembered);
+    }
+    const p = refreshCodexAccount(creds)
+        .then((fresh) => {
+        noteRefreshRecovered(creds.alias);
+        return fresh;
+    })
+        .catch((err) => {
+        throw new CodexCredentialsUnavailableError(creds.alias, noteRefreshFailure(creds.alias, err));
+    })
+        .finally(() => {
         inflightRefresh.delete(creds.alias);
     });
     inflightRefresh.set(creds.alias, p);

package/dist/codex-backend.d.ts

@@ -113,6 +113,24 @@ export declare function pickClaudeTarget(models: readonly string[], slugs: reado
  * header, which is what the CLI does for accounts without a workspace.
  */
 export declare function extractChatGPTAccountId(idToken: string | undefined): string | null;
+/** True when a chat field survives BOTH translation and the Codex scrub. */
+export declare function chatFieldReachesCodex(field: string): boolean;
+/** Report each chat field that never reaches Codex, once per process. */
+export declare function logUnsupportedChatFields(body: Record<string, unknown>, verbose: boolean): void;
+/**
+ * Translate a chat/completions `tool_choice` into the Responses shape.
+ *
+ * The two APIs agree on the string forms ("auto"/"none"/"required") but not on
+ * the forced-tool form: chat/completions nests the name under `function`,
+ * Responses takes it FLAT. Forwarding the nested form verbatim makes the Codex
+ * backend answer 400 "Missing required parameter: 'tool_choice.name'", which is
+ * what every client that forces a tool (Cursor, Continue, Aider) sends. Mirrors
+ * translateToolChoice() on the Anthropic path.
+ *
+ * Anything else passes through untouched: an unknown object is the backend's to
+ * reject, not ours to guess at. Pure; exported for tests.
+ */
+export declare function toResponsesToolChoice(choice: unknown): unknown;
 /**
  * Translate an OpenAI chat/completions request body into a Responses request.
  *
@@ -141,6 +159,8 @@ export declare function isTerminalResponsesEvent(type: string): boolean;
 export declare function isFailedResponse(resp: unknown): boolean;
 /** The upstream message on a failed Responses payload, for the error body. */
 export declare function failedResponseMessage(resp: unknown): string;
+/** The upstream error code on a failed Responses payload, or null when absent. */
+export declare function failedResponseCode(resp: unknown): string | null;
 /**
  * Stateful per-request translator: Responses SSE in, chat/completions out.
  *

package/dist/codex-backend.js

@@ -180,6 +180,46 @@ export function extractChatGPTAccountId(idToken) {
         return null;
     }
 }
+/**
+ * Which Responses field each chat/completions field is translated into.
+ *
+ * Translation is only half the transport: `toCodexSupportedBody` scrubs the
+ * translated body again, so a chat field reaches Codex only when its
+ * TRANSLATED name also survives that allowlist. `temperature` and `top_p`
+ * are translated by name and `max_tokens`/`max_completion_tokens` become
+ * `max_output_tokens` — all four are then scrubbed away, so the diagnostic
+ * has to report them as dropped. A caller passing `temperature: 0` needs to
+ * hear that precisely because the translation step looks like it worked.
+ */
+const CHAT_COMPLETIONS_FIELD_TRANSLATIONS = {
+    model: 'model',
+    messages: 'input',
+    tools: 'tools',
+    tool_choice: 'tool_choice',
+    stream: 'stream',
+    reasoning_effort: 'reasoning',
+    temperature: 'temperature',
+    top_p: 'top_p',
+    max_tokens: 'max_output_tokens',
+    max_completion_tokens: 'max_output_tokens',
+};
+const loggedUnsupportedChatFields = new Set();
+/** True when a chat field survives BOTH translation and the Codex scrub. */
+export function chatFieldReachesCodex(field) {
+    const target = CHAT_COMPLETIONS_FIELD_TRANSLATIONS[field];
+    return target !== undefined && CODEX_SUPPORTED_FIELDS.includes(target);
+}
+/** Report each chat field that never reaches Codex, once per process. */
+export function logUnsupportedChatFields(body, verbose) {
+    if (!verbose)
+        return;
+    for (const field of Object.keys(body)) {
+        if (chatFieldReachesCodex(field) || loggedUnsupportedChatFields.has(field))
+            continue;
+        loggedUnsupportedChatFields.add(field);
+        console.log(`[dario] codex: dropping unsupported chat field ${field}`);
+    }
+}
 function messageContentToText(content) {
     if (typeof content === 'string')
         return content;
@@ -193,6 +233,60 @@ function messageContentToText(content) {
     }
     return content == null ? '' : JSON.stringify(content);
 }
+/** Preserve OpenAI chat text and image_url parts in a Responses user item. */
+function chatContentToResponsesParts(content) {
+    if (!Array.isArray(content))
+        return [{ type: 'input_text', text: messageContentToText(content) }];
+    const parts = [];
+    for (const part of content) {
+        const p = part;
+        if (p?.type === 'text' && typeof p.text === 'string') {
+            parts.push({ type: 'input_text', text: p.text });
+            continue;
+        }
+        if (p?.type === 'image_url') {
+            const obj = typeof p.image_url === 'object' && p.image_url !== null
+                ? p.image_url
+                : undefined;
+            const imageUrl = typeof p.image_url === 'string' ? p.image_url : obj?.url;
+            if (typeof imageUrl === 'string') {
+                // `detail` is a fidelity/cost control the Responses input_image part
+                // takes too; dropping it silently downgrades a low-detail request to
+                // the backend's automatic behaviour and changes image-token cost.
+                const detail = obj?.detail;
+                parts.push({
+                    type: 'input_image',
+                    image_url: imageUrl,
+                    ...(detail === 'auto' || detail === 'low' || detail === 'high' ? { detail } : {}),
+                });
+            }
+        }
+    }
+    return parts;
+}
+/**
+ * Translate a chat/completions `tool_choice` into the Responses shape.
+ *
+ * The two APIs agree on the string forms ("auto"/"none"/"required") but not on
+ * the forced-tool form: chat/completions nests the name under `function`,
+ * Responses takes it FLAT. Forwarding the nested form verbatim makes the Codex
+ * backend answer 400 "Missing required parameter: 'tool_choice.name'", which is
+ * what every client that forces a tool (Cursor, Continue, Aider) sends. Mirrors
+ * translateToolChoice() on the Anthropic path.
+ *
+ * Anything else passes through untouched: an unknown object is the backend's to
+ * reject, not ours to guess at. Pure; exported for tests.
+ */
+export function toResponsesToolChoice(choice) {
+    if (choice == null || typeof choice !== 'object')
+        return choice;
+    const c = choice;
+    const name = c.function?.name;
+    if (typeof name === 'string' && name.length > 0) {
+        return { type: 'function', name };
+    }
+    return choice;
+}
 /**
  * Translate an OpenAI chat/completions request body into a Responses request.
  *
@@ -239,7 +333,7 @@ export function chatCompletionsToResponses(body) {
             }
             continue;
         }
-        input.push({ role: 'user', content: [{ type: 'input_text', text: messageContentToText(m.content) }] });
+        input.push({ role: 'user', content: chatContentToResponsesParts(m.content) });
     }
     const out = {
         model: String(body.model ?? ''),
@@ -259,7 +353,7 @@ export function chatCompletionsToResponses(body) {
         }));
     }
     if (body.tool_choice != null)
-        out.tool_choice = body.tool_choice;
+        out.tool_choice = toResponsesToolChoice(body.tool_choice);
     if (body.temperature != null)
         out.temperature = body.temperature;
     if (body.top_p != null)
@@ -297,6 +391,11 @@ export function failedResponseMessage(resp) {
     const code = e && typeof e.code === 'string' ? e.code : '';
     return msg || code || 'the Codex backend ended the response as failed';
 }
+/** The upstream error code on a failed Responses payload, or null when absent. */
+export function failedResponseCode(resp) {
+    const e = resp?.error;
+    return e && typeof e.code === 'string' && e.code ? e.code : null;
+}
 /**
  * Stateful per-request translator: Responses SSE in, chat/completions out.
  *
@@ -410,6 +509,21 @@ export function createResponsesTranslator(model) {
                         total_tokens: (u.input_tokens ?? 0) + (u.output_tokens ?? 0),
                     };
                 }
+                if (failed) {
+                    // A failed turn must NOT close like a finished one: a
+                    // `finish_reason:"stop"` frame is, to every OpenAI SDK, a successful
+                    // empty completion, so the failure disappears entirely. Emit the
+                    // error frame instead — openai-node's ChatCompletionStream and
+                    // openai-python both raise on a chunk carrying `error` — then
+                    // `[DONE]` so the parser terminates rather than waiting.
+                    return opened(`data: ${JSON.stringify({
+                        error: {
+                            message: failedResponseMessage(e.response),
+                            type: 'server_error',
+                            code: failedResponseCode(e.response),
+                        },
+                    })}\n\ndata: [DONE]\n\n`);
+                }
                 return opened(`${frame({}, toolCalls.size > 0 ? 'tool_calls' : 'stop')}data: [DONE]\n\n`);
             }
             return null;
@@ -551,6 +665,8 @@ export async function forwardToCodex(req, res, body, creds, corsOrigin, security
         report(400, null, false, '');
         return true;
     }
+    if (!isAnthropic)
+        logUnsupportedChatFields(parsed, verbose);
     const clientWantsStream = parsed.stream === true;
     const model = String(parsed.model ?? '');
     // stream is forced: the backend is always streamed and collapsed here.
@@ -560,6 +676,31 @@ export async function forwardToCodex(req, res, body, creds, corsOrigin, security
     const scrubbed = toCodexSupportedBody(upstreamBody);
     const target = `${CODEX_BACKEND_BASE_URL.replace(/\/$/, '')}/responses`;
     const abort = new AbortController();
+    // Once the client is gone there is nobody left to write to, but the upstream
+    // Responses stream keeps generating — and the ChatGPT subscription keeps
+    // paying for output nobody will read. Aborting the fetch is what stops the
+    // meter; `clientGone` stops us writing to a socket we no longer have.
+    // `finished` tells our own teardown apart from a client that walked away,
+    // the same distinction proxy.ts makes with res.writableEnded.
+    let finished = false;
+    let clientGone = false;
+    const onClientClose = () => {
+        if (finished || clientGone)
+            return;
+        clientGone = true;
+        if (verbose)
+            console.log(`[dario] codex client disconnected (${creds.alias}) — aborting upstream`);
+        if (!abort.signal.aborted)
+            abort.abort();
+    };
+    res.on('close', onClientClose);
+    // Every streamed write goes through here: after a disconnect the socket is
+    // gone and writing to it is wasted at best, an EPIPE at worst.
+    const write = (chunk) => { if (!clientGone)
+        res.write(chunk); };
+    // Usage seen so far, so a stream the client abandoned still reports what the
+    // subscription already spent. Populated once the translators exist.
+    let usageSoFar = () => null;
     const timeout = setTimeout(() => abort.abort(), upstreamTimeoutMs);
     try {
         if (verbose)
@@ -574,6 +715,15 @@ export async function forwardToCodex(req, res, body, creds, corsOrigin, security
             const detail = await upstream.text().catch(() => '');
             if (verbose)
                 console.error(`[dario] codex backend ${upstream.status}: ${detail.slice(0, 300)}`);
+            // The client can hang up while this buffered error body is being read:
+            // an already-arrived response resolves regardless of the abort, so the
+            // signal never rejects here. With nobody left to serve, a decline would
+            // hand the chain a request whose only remaining effect is billing the
+            // next provider for output no one reads.
+            if (clientGone) {
+                report(499, usageSoFar(), clientWantsStream, model);
+                return true;
+            }
             // "Not right now" — a rate limit or an upstream fault — is the caller's
             // cue to fail over, not something to hand the client. A 4xx that is our
             // own fault (a bad body, an unsupported parameter) is NOT: failing over
@@ -608,6 +758,11 @@ export async function forwardToCodex(req, res, body, creds, corsOrigin, security
         const antAssembler = isAnthropic ? createAnthropicMessageAssembler() : null;
         let terminalResponse = null;
         let anthropicFailed = false;
+        // Reported on the abandoned-client exit as well as the normal one, so a
+        // stream the client walked away from still shows what it already spent.
+        usageSoFar = isAnthropic
+            ? () => { const tr = terminalResponse; return tr?.usage ? { input: Number(tr.usage.input_tokens ?? 0), output: Number(tr.usage.output_tokens ?? 0) } : null; }
+            : () => { const u = translator.usage(); return u ? { input: u.prompt_tokens, output: u.completion_tokens } : null; };
         const emitAnthropic = (events) => {
             for (const ev of events) {
                 const t = ev.type ?? '';
@@ -623,7 +778,7 @@ export async function forwardToCodex(req, res, body, creds, corsOrigin, security
                     antAssembler.push(produced);
                 for (const out of produced) {
                     if (clientWantsStream)
-                        res.write(formatResponsesAnthropicSSE(out));
+                        write(formatResponsesAnthropicSSE(out));
                 }
             }
         };
@@ -645,6 +800,10 @@ export async function forwardToCodex(req, res, body, creds, corsOrigin, security
                     const { done, value } = await reader.read();
                     if (done)
                         break;
+                    // The abort above normally makes this read reject; a stream that
+                    // ignores its signal must not keep us looping for a client that left.
+                    if (clientGone)
+                        break;
                     const decoded = decoder.decode(value, { stream: true });
                     if (isAnthropic) {
                         // The parser owns its own partial-frame buffering.
@@ -658,7 +817,7 @@ export async function forwardToCodex(req, res, body, creds, corsOrigin, security
                     for (const line of lines) {
                         const out = translator.chunk(line);
                         if (out && clientWantsStream)
-                            res.write(out);
+                            write(out);
                     }
                 }
             }
@@ -671,9 +830,17 @@ export async function forwardToCodex(req, res, body, creds, corsOrigin, security
             else if (buffered.length > 0) {
                 const out = translator.chunk(buffered);
                 if (out && clientWantsStream)
-                    res.write(out);
+                    write(out);
             }
         }
+        // The client left mid-stream: upstream is aborted, the socket is gone and
+        // there is nothing left to collapse or send. 499 is nginx's "client closed
+        // request" — the request happened and cost tokens, so it is reported, but
+        // it is neither an upstream failure nor a decline.
+        if (clientGone) {
+            report(499, usageSoFar(), clientWantsStream, model);
+            return true;
+        }
         // A stream that ended in failure must not collapse into a 200 with empty
         // content: to a non-streaming client that is indistinguishable from a model
         // that chose to say nothing. Streaming clients already saw the terminal
@@ -686,6 +853,7 @@ export async function forwardToCodex(req, res, body, creds, corsOrigin, security
             if (verbose)
                 console.error(`[dario] codex backend (${creds.alias}) response failed: ${detail}`);
             res.writeHead(502, { 'Content-Type': 'application/json', ...securityHeaders });
+            finished = true;
             res.end(errBody(`Codex backend response failed: ${detail}`, { account: creds.alias }));
             report(502, null, clientWantsStream, model);
             return true;
@@ -693,7 +861,8 @@ export async function forwardToCodex(req, res, body, creds, corsOrigin, security
         if (isAnthropic) {
             if (clientWantsStream) {
                 for (const out of antTranslator.end())
-                    res.write(formatResponsesAnthropicSSE(out));
+                    write(formatResponsesAnthropicSSE(out));
+                finished = true;
                 res.end();
             }
             else {
@@ -703,10 +872,12 @@ export async function forwardToCodex(req, res, body, creds, corsOrigin, security
                     ...securityHeaders,
                 });
                 antAssembler.push(antTranslator.end());
+                finished = true;
                 res.end(JSON.stringify(antAssembler.message(model)));
             }
         }
         else if (clientWantsStream) {
+            finished = true;
             res.end();
         }
         else {
@@ -715,18 +886,13 @@ export async function forwardToCodex(req, res, body, creds, corsOrigin, security
                 'Access-Control-Allow-Origin': corsOrigin,
                 ...securityHeaders,
             });
+            finished = true;
             res.end(JSON.stringify(translator.complete()));
         }
         // Token usage rides the terminal Responses event on either shape. A stream
         // that failed upstream still ended as 200 on the wire (the client saw the
         // failure event); analytics must count it as the 502 it was.
-        {
-            const tr = terminalResponse;
-            const usage = isAnthropic
-                ? (tr?.usage ? { input: Number(tr.usage.input_tokens ?? 0), output: Number(tr.usage.output_tokens ?? 0) } : null)
-                : (() => { const u = translator.usage(); return u ? { input: u.prompt_tokens, output: u.completion_tokens } : null; })();
-            report(upstreamFailed ? 502 : 200, usage, clientWantsStream, model);
-        }
+        report(upstreamFailed ? 502 : 200, usageSoFar(), clientWantsStream, model);
         return true;
     }
     catch (err) {
@@ -735,6 +901,16 @@ export async function forwardToCodex(req, res, body, creds, corsOrigin, security
         const detail = err instanceof Error ? err.message : String(err);
         if (verbose)
             console.error(`[dario] codex backend (${creds.alias}) error: ${detail}`);
+        // A client that hung up aborted this fetch itself. That is not the
+        // subscription declining — failing over would re-bill a request nobody is
+        // reading — and there is no socket left to write a 502 to. This has to be
+        // checked BEFORE the decline branch: an abort that fires before the first
+        // byte still leaves headersSent false, which would otherwise look exactly
+        // like an unreachable backend and trigger a pointless failover.
+        if (clientGone) {
+            report(499, usageSoFar(), clientWantsStream, model);
+            return true;
+        }
         // A transport failure before any byte was written is the same "not right
         // now" as a 429: DNS, a refused connection, a reset socket or our own
         // upstream timeout all mean this subscription did not answer, and none of
@@ -756,9 +932,11 @@ export async function forwardToCodex(req, res, body, creds, corsOrigin, security
         }
         if (!res.headersSent) {
             res.writeHead(502, { 'Content-Type': 'application/json', ...securityHeaders });
+            finished = true;
             res.end(errBody('Upstream Codex backend error', { account: creds.alias }));
         }
         else {
+            finished = true;
             try {
                 res.end();
             }
@@ -769,5 +947,6 @@ export async function forwardToCodex(req, res, body, creds, corsOrigin, security
     }
     finally {
         clearTimeout(timeout);
+        res.removeListener('close', onClientClose);
     }
 }

package/dist/codex-oauth.d.ts

@@ -9,6 +9,21 @@ export interface CodexTokens {
     expiresAt: number;
     idToken?: string;
 }
+/**
+ * A refresh the token endpoint REJECTED, carrying the two facts the caller
+ * needs to act on it: the HTTP status (a 400/401 `invalid_grant` is a dead
+ * refresh token and re-asking will never help; a 5xx or a transport failure
+ * may clear on its own) and a short snippet of the body for the operator.
+ *
+ * The message keeps its old shape so anything matching on the text still
+ * matches; `status`/`bodySnippet` exist so codex-accounts.ts can record the
+ * failure without re-parsing prose. `status` is 0 when no response arrived.
+ */
+export declare class CodexRefreshError extends Error {
+    readonly status: number;
+    readonly bodySnippet: string;
+    constructor(status: number, bodySnippet: string);
+}
 export declare function generateCodexPKCE(): {
     codeVerifier: string;
     codeChallenge: string;

package/dist/codex-oauth.js

@@ -33,6 +33,26 @@ export const CODEX_AUTHORIZE_URL = process.env.DARIO_CODEX_AUTHORIZE_URL || 'htt
 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';
+/**
+ * A refresh the token endpoint REJECTED, carrying the two facts the caller
+ * needs to act on it: the HTTP status (a 400/401 `invalid_grant` is a dead
+ * refresh token and re-asking will never help; a 5xx or a transport failure
+ * may clear on its own) and a short snippet of the body for the operator.
+ *
+ * The message keeps its old shape so anything matching on the text still
+ * matches; `status`/`bodySnippet` exist so codex-accounts.ts can record the
+ * failure without re-parsing prose. `status` is 0 when no response arrived.
+ */
+export class CodexRefreshError extends Error {
+    status;
+    bodySnippet;
+    constructor(status, bodySnippet) {
+        super(`Codex token refresh failed (${status}): ${bodySnippet}`);
+        this.name = 'CodexRefreshError';
+        this.status = status;
+        this.bodySnippet = bodySnippet;
+    }
+}
 function base64url(buf) {
     return buf.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
 }
@@ -108,7 +128,7 @@ export async function refreshCodexAccessToken(refreshToken) {
     });
     if (!res.ok) {
         const body = await res.text().catch(() => '');
-        throw new Error(`Codex token refresh failed (${res.status}): ${body.slice(0, 200)}`);
+        throw new CodexRefreshError(res.status, body.slice(0, 200));
     }
     return parseTokenResponse(await res.json());
 }

package/dist/proxy.js

@@ -22,7 +22,7 @@ import { createTokenBucket } from './rate-limit.js';
 import { getOpenAIBackend, isOpenAIModel, forwardToOpenAI } from './openai-backend.js';
 import { forwardToCodex, getCodexModelSlugs, peekCodexModelSlugs, pickCodexFallback, pickClaudeTarget, CODEX_BACKEND_BASE_URL } from './codex-backend.js';
 import { readCompareTarget, teeResponse, runCompare, writeCompareRecord, COMPARE_RESULT_HEADER } from './compare.js';
-import { listCodexAccountAliases, loadAllCodexAccounts, codexAccountNeedsRefresh, hasAnyCodexAccount, selectCodexAccount, getFreshCodexAccount } from './codex-accounts.js';
+import { listCodexAccountAliases, loadAllCodexAccounts, codexAccountNeedsRefresh, hasAnyCodexAccount, selectCodexAccount, getFreshCodexAccount, getCodexRefreshFailure, CodexCredentialsUnavailableError } from './codex-accounts.js';
 import { route as routeProvider } from './provider-adapter.js';
 import { selectPoolFallbackModels } from './pool-fallback-tier.js';
 import { RequestQueue, QueueFullError, QueueTimeoutError, DEFAULT_MAX_CONCURRENT, DEFAULT_MAX_QUEUED, DEFAULT_QUEUE_TIMEOUT_MS } from './request-queue.js';
@@ -2190,6 +2190,11 @@ export async function startProxy(opts = {}) {
                 needsRefresh: codexAccountNeedsRefresh(a),
                 models: peekCodexModelSlugs(a.alias) ?? [],
                 requestCount: codexRequestCounts.get(a.alias) ?? 0,
+                // Why an account that LOOKS present is serving nothing: the last
+                // token-endpoint rejection, remembered in-process for a minute
+                // (DEV-179a412f). Read from memory only — a status read never spends
+                // or exposes a credential, so there is no token in {at,status,message}.
+                lastRefreshError: getCodexRefreshFailure(a.alias),
             }));
             res.writeHead(200, JSON_HEADERS);
             res.end(JSON.stringify({
@@ -2528,6 +2533,26 @@ export async function startProxy(opts = {}) {
                     reason: ALL_PROVIDERS_RATE_LIMITED,
                 }));
             };
+            /**
+             * The codex route was named — by a listed slug or a `codex:` prefix —
+             * but that account's credentials could not be refreshed (DEV-179a412f).
+             *
+             * Before this the throw was swallowed by the JSON-peek `catch` around the
+             * routing block, so the route silently disappeared and the request fell to
+             * the Claude path, where an empty pool answered "No account configured …
+             * run `dario login`" — pointing the operator at the wrong subscription
+             * entirely. Answer about the CODEX account instead, in the client's own
+             * wire shape.
+             */
+            const writeCodexCredentialsUnavailable = (err, shape) => {
+                const message = `Codex account "${err.alias}" cannot refresh its token (${err.status || 'no response'} from the OpenAI token endpoint). `
+                    + `This is the ChatGPT subscription, not the Claude one — re-add it with \`dario codex add ${err.alias}\`.`;
+                console.log(`[dario] #${requestCount} codex account ${err.alias} credentials unavailable — 503`);
+                res.writeHead(503, { ...JSON_HEADERS, 'x-dario-upstream-rejection': 'credential_rejected' });
+                res.end(JSON.stringify(shape === 'anthropic'
+                    ? { type: 'error', error: { type: 'authentication_error', message }, account: err.alias }
+                    : { error: message, account: err.alias }));
+            };
             const selectPoolAccount = () => {
                 if (upstreamApiKey) {
                     // Per-token API-key mode: no OAuth, no pool selection. `poolAccount`
@@ -2781,11 +2806,28 @@ export async function startProxy(opts = {}) {
                     // an account added while the proxy runs routes on the very next
                     // request; the absent answer is cached ~30s, so an idle proxy with
                     // no codex account is not stat-ing the filesystem per request.
+                    // Credentials that exist on disk but could not be refreshed. Kept
+                    // separately from `codexCreds` so the decision below can still see
+                    // that this request was BOUND for codex and answer about that
+                    // account, rather than letting the throw escape into the JSON-peek
+                    // catch below and disappear (DEV-179a412f).
+                    let codexUnavailable = null;
                     if (await hasAnyCodexAccount()) {
                         const stored = await selectCodexAccount();
                         if (stored) {
-                            codexCreds = await getFreshCodexAccount(stored);
-                            codexModels = await getCodexModelSlugs(codexCreds);
+                            try {
+                                codexCreds = await getFreshCodexAccount(stored);
+                                codexModels = await getCodexModelSlugs(codexCreds);
+                            }
+                            catch (err) {
+                                if (!(err instanceof CodexCredentialsUnavailableError))
+                                    throw err;
+                                codexUnavailable = err;
+                                // Cached slugs only — never an upstream call with a credential
+                                // already known to be bad. Enough to answer the routing
+                                // question "was this request the subscription's to serve".
+                                codexModels = peekCodexModelSlugs(stored.alias) ?? [];
+                            }
                         }
                     }
                     const decision = routeProvider({
@@ -2793,11 +2835,16 @@ export async function startProxy(opts = {}) {
                         model: rawModel,
                         forcedProvider,
                         hasOpenAIBackend: openaiBackend !== null,
-                        hasCodexAccount: codexCreds !== null,
+                        hasCodexAccount: codexCreds !== null || codexUnavailable !== null,
                         codexModels,
                         poolFallbackModel: requestPoolFallbackModel,
                         poolSize: pool.size,
                     });
+                    if (rawModel && codexUnavailable && decision.provider === 'codex') {
+                        requestCount++;
+                        writeCodexCredentialsUnavailable(codexUnavailable, isOpenAI ? 'openai' : 'anthropic');
+                        return;
+                    }
                     if (rawModel && codexCreds && decision.provider === 'codex') {
                         if (verbose) {
                             console.log(`[dario] #${requestCount} ${req.method} ${urlPath} (model: ${rawModel}) → codex account ${codexCreds.alias}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "6.0.21",
+  "version": "6.0.22",
   "description": "Use your Claude Pro/Max subscription in any tool — Cursor, Cline, Aider, the Agent SDK, your scripts — at subscription pricing, not per-token API bills. One local Anthropic + OpenAI-compatible endpoint.",
   "type": "module",
   "bin": {