@askalf/dario 6.0.30 → 6.0.32

package/dist/proxy.js

@@ -23,6 +23,8 @@ import { handleAdminRequest } from './admin-api.js';
 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 { isClaudeServableModel } from './claude-model.js';
+import { MODEL_UNROUTABLE } from './upstream-rejection.js';
 import { readCompareTarget, teeResponse, runCompare, writeCompareRecord, COMPARE_RESULT_HEADER } from './compare.js';
 import { listCodexAccountAliases, loadAllCodexAccounts, codexAccountNeedsRefresh, hasAnyCodexAccount, selectCodexAccount, getFreshCodexAccount, getCodexRefreshFailure, CodexCredentialsUnavailableError } from './codex-accounts.js';
 import { route as routeProvider } from './provider-adapter.js';
@@ -2726,6 +2728,11 @@ export async function startProxy(opts = {}) {
             // wire shape, and no upstream round-trip for a request nothing can serve.
             // Upstreams do the same (Anthropic: "The request body is not valid
             // JSON"; OpenAI: "We could not parse the JSON body of your request").
+            //
+            // The object this guard parses is kept as `parsedBody` and reused by the
+            // provider-prefix block and the template build below, so the bytes are
+            // JSON.parsed once per request (#642-audit; second-read finding on #1231).
+            let parsedBody = null;
             {
                 let invalid = null;
                 if (body.length === 0)
@@ -2740,6 +2747,8 @@ export async function startProxy(opts = {}) {
                         const v = JSON.parse(text);
                         if (v === null || typeof v !== 'object' || Array.isArray(v))
                             invalid = 'request body must be a JSON object';
+                        else
+                            parsedBody = v;
                     }
                     catch (err) {
                         invalid = `request body is not valid JSON: ${err instanceof Error ? err.message : String(err)}`;
@@ -2775,15 +2784,14 @@ export async function startProxy(opts = {}) {
             // recognizes through its own Anthropic gateway, bypassing localhost).
             let forcedProvider = cliProviderOverride;
             let requestEffort; // dario#419 — per-request effort parsed from a model-name suffix (model:high / model-high)
-            // Parsed body, shared between the provider-prefix detection below and the
-            // template-build block further down so the same bytes are not JSON.parsed
-            // twice per request (#642-audit). Mutations in the prefix block re-serialize
-            // `body` FROM this object, so it always represents the current body.
-            let parsedBody = null;
-            if (body.length > 0) {
+            // `parsedBody` was parsed by the invalid-body guard above and is shared
+            // with the template-build block further down so the same bytes are not
+            // JSON.parsed twice per request (#642-audit). Mutations in the prefix block
+            // re-serialize `body` FROM this object, so it always represents the current
+            // body.
+            if (parsedBody !== null) {
                 try {
-                    const parsed = JSON.parse(body.toString());
-                    parsedBody = parsed;
+                    const parsed = parsedBody;
                     // User-defined aliases first — before provider-prefix parsing, so
                     // an alias target carrying a prefix (`my-fast` → `openai:gpt-4o`)
                     // retargets the backend through the existing machinery below.
@@ -2927,7 +2935,7 @@ export async function startProxy(opts = {}) {
             // reaches the subscription even when an API-key backend is configured too.
             if (body.length > 0) {
                 try {
-                    const peek = JSON.parse(body.toString());
+                    const peek = (parsedBody ?? {}); // parsed once by the invalid-body guard; `body` is re-serialized from it
                     const rawModel = (peek.model || '').toString();
                     const requestPoolFallbackModels = selectPoolFallbackModels(poolFallbackSpec, rawModel);
                     const requestPoolFallbackModel = requestPoolFallbackModels[0] ?? null;
@@ -3040,7 +3048,9 @@ export async function startProxy(opts = {}) {
                                 account: o.alias,
                                 model: o.model || rawModel || 'codex',
                                 inputTokens: o.inputTokens, outputTokens: o.outputTokens,
-                                cacheReadTokens: 0, cacheCreateTokens: 0, thinkingTokens: 0,
+                                // Anthropic convention, like every other row: inputTokens is
+                                // net of the cached prefix, which sits in cacheReadTokens.
+                                cacheReadTokens: o.cacheReadTokens, cacheCreateTokens: o.cacheCreateTokens, thinkingTokens: 0,
                                 // No Anthropic rate-limit headers on this path; the claim
                                 // names the engine and is subscription billing, so the
                                 // overage guard (#288) leaves it alone.
@@ -3051,8 +3061,14 @@ export async function startProxy(opts = {}) {
                                 ts: new Date().toISOString(), req: codexReq,
                                 method: req.method ?? '', path: urlPath, model: o.model || rawModel || undefined,
                                 status: o.status, latency_ms: o.latencyMs, in_tokens: o.inputTokens, out_tokens: o.outputTokens,
+                                cache_read: o.cacheReadTokens, cache_create: o.cacheCreateTokens,
                                 claim: CODEX_CLAIM, bucket: 'subscription', account: o.alias, stream: o.stream,
                             });
+                            if (verbose)
+                                console.log(formatUsageLogLine(codexReq, {
+                                    inputTokens: o.inputTokens, outputTokens: o.outputTokens,
+                                    cacheReadTokens: o.cacheReadTokens, cacheCreateTokens: o.cacheCreateTokens,
+                                }));
                         }, 
                         // Cool codex on a rate limit only — a 5xx or an unreachable backend
                         // is an outage, and parking a provider for that would keep it out
@@ -3109,6 +3125,42 @@ export async function startProxy(opts = {}) {
                         await forwardToOpenAI(req, res, body, openaiBackend, corsOrigin, SECURITY_HEADERS, upstreamTimeoutMs, verbose);
                         return;
                     }
+                    // dario#1236 — the Claude adapter claims by default, so a model NO
+                    // provider lists used to reach api.anthropic.com verbatim and come
+                    // back as Anthropic's 404 `model: gpt-5.6-sol`, attributed to
+                    // whichever seat sent it, after spending a pool request. Ask the
+                    // positive question the failover chain already asks (claude-model.ts)
+                    // and refuse locally instead.
+                    //
+                    // Deliberately NOT refused: a `claude-*` name the catalog does not
+                    // know (the live catalog can lag a model by a fetch, and on a cold
+                    // start it is the baked list — Anthropic's own 404 stays
+                    // authoritative for those); a request under a server-wide
+                    // --model/--fast-model override, which replaces the name; upstream
+                    // API-key mode, which has no pool to protect and may reach models the
+                    // OAuth catalog never lists; and an OpenAI-shape name the legacy
+                    // OPENAI_MODEL_MAP translates to a Claude model.
+                    if (rawModel && decision.provider === 'claude' && !upstreamApiKey && !modelOverride && !fastModelOverride
+                        && !(isOpenAI && OPENAI_MODEL_MAP[rawModel])
+                        && !/^claude-/i.test(rawModel.trim())
+                        && !isClaudeServableModel(rawModel, getCachedBases(), (m) => resolveClaudeAlias(applyModelAlias(m, modelAliases) ?? m))) {
+                        const consulted = [
+                            codexCreds || codexUnavailable
+                                ? `codex account ${(codexCreds ?? codexUnavailable).alias} (${codexModels.length} listed slug${codexModels.length === 1 ? '' : 's'})`
+                                : 'no codex account',
+                            openaiBackend ? `openai backend ${openaiBackend.name}${isOpenAI ? '' : ' (OpenAI path only)'}` : 'no openai backend',
+                            `claude catalog (${getCachedBases().length} bases)`,
+                        ].join(', ');
+                        if (verbose)
+                            console.log(`[dario] #${requestCount} ${req.method} ${urlPath} (model: ${rawModel}) no provider lists ${rawModel}; refusing — consulted ${consulted}`);
+                        requestCount++;
+                        const message = `no provider lists model "${rawModel}" (consulted ${consulted}); refused locally rather than forwarded to the Claude pool, which would 404 it after spending a request`;
+                        res.writeHead(400, { ...JSON_HEADERS, 'x-dario-upstream-rejection': MODEL_UNROUTABLE });
+                        res.end(JSON.stringify(isOpenAI
+                            ? { error: { message, type: 'invalid_request_error', param: 'model', code: 'model_not_found' } }
+                            : { type: 'error', error: { type: 'invalid_request_error', message } }));
+                        return;
+                    }
                 }
                 catch { /* not JSON — fall through to existing path */ }
             }

package/dist/upstream-rejection.d.ts

@@ -3,6 +3,14 @@ export interface UpstreamRejection {
     class: UpstreamRejectionClass;
     marker: 'billing_required' | 'rate_limited' | 'credential_rejected' | 'upstream_rejected';
 }
+/**
+ * `x-dario-upstream-rejection` value for a request dario refused LOCALLY
+ * because no provider lists its model (dario#1236). Not a classification of
+ * an upstream answer — there was no upstream request, which is the point — but
+ * it rides the same header so a fleet log or tracker reads one field for
+ * every "this request was not served" verdict.
+ */
+export declare const MODEL_UNROUTABLE = "model_unroutable";
 /** Classify subscription entitlement failures separately from temporary quota exhaustion. */
 export declare function classifyUpstreamRejection(status: number, body: string): UpstreamRejection;
 /** Operator action paired with the failure class. Never suggest credential churn for billing. */

package/dist/upstream-rejection.js

@@ -1,3 +1,11 @@
+/**
+ * `x-dario-upstream-rejection` value for a request dario refused LOCALLY
+ * because no provider lists its model (dario#1236). Not a classification of
+ * an upstream answer — there was no upstream request, which is the point — but
+ * it rides the same header so a fleet log or tracker reads one field for
+ * every "this request was not served" verdict.
+ */
+export const MODEL_UNROUTABLE = 'model_unroutable';
 /** Classify subscription entitlement failures separately from temporary quota exhaustion. */
 export function classifyUpstreamRejection(status, body) {
     const normalized = body.toLowerCase();

package/docs/integrations/cordon.md

@@ -24,8 +24,8 @@ services:
     expose: ["3456"]
 
   cordon:
-    # cordon does not publish an image yet; build it from the repo.
-    build: https://github.com/askalf/cordon.git
+    # multi-arch, Sigstore-attested: gh attestation verify oci://ghcr.io/askalf/cordon:v0.2.0 --repo askalf/cordon
+    image: ghcr.io/askalf/cordon:v0.2.0
     environment:
       ANTHROPIC_BASE: http://dario:3456
       OPENAI_BASE: http://dario:3456

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "6.0.30",
+  "version": "6.0.32",
   "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": {
@@ -40,7 +40,9 @@
     "check:overage": "node scripts/check-overage-live.mjs",
     "cch:calibrate": "node scripts/cch-calibrate.mjs",
     "fix:pkg": "node -e \"const fs=require('fs');fs.writeFileSync('package.json',JSON.stringify(JSON.parse(fs.readFileSync('package.json','utf-8')),null,2)+'\\n')\"",
-    "audit:tui": "node tools/tui-audit/audit.mjs"
+    "audit:tui": "node tools/tui-audit/audit.mjs",
+    "readme:assets": "node scripts/readme/hero.mjs && node scripts/readme/terminal.mjs && node scripts/readme/tui.mjs",
+    "check:readme": "node scripts/check-readme-line-count.mjs && node scripts/check-readme-links.mjs"
   },
   "keywords": [
     "llm",