@askalf/dario 6.0.36 → 6.0.38

package/dist/anthropic-responses-translate.d.ts

@@ -221,7 +221,14 @@ export type ResponsesToolChoice = 'auto' | 'none' | 'required' | {
     name: string;
 };
 export interface ResponsesReasoningConfig {
-    effort?: 'low' | 'medium' | 'high';
+    /**
+     * The backend accepts more levels than the thinking-budget mapping can
+     * produce: probed 2026-08-29 against a live account, `none, minimal, low,
+     * medium, high, xhigh, max` are all valid and `ultra` 400s. The wider set
+     * is reachable only when a caller names an effort outright (dario#1260);
+     * `thinkingToReasoningEffort` still only ever yields low/medium/high.
+     */
+    effort?: 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
     summary?: 'auto' | 'concise' | 'detailed';
 }
 export interface ResponsesRequest {
@@ -338,9 +345,13 @@ export interface ResponsesResponse {
  * (max_output_tokens caps reasoning + output combined on the Responses API).
  */
 export declare const REASONING_HEADROOM: {
+    readonly none: 0;
+    readonly minimal: 6000;
     readonly low: 12000;
     readonly medium: 25000;
     readonly high: 50000;
+    readonly xhigh: 80000;
+    readonly max: 120000;
 };
 /** gpt-5.x / o-series output ceiling (tokens). */
 export declare const RESPONSES_MAX_OUTPUT_CAP = 128000;
@@ -352,6 +363,14 @@ export interface AnthropicToResponsesOptions {
      * Pass `null` to omit `summary` entirely.
      */
     reasoningSummary?: 'auto' | 'concise' | 'detailed' | null;
+    /**
+     * Force `reasoning.effort`, overriding whatever `thinking.budget_tokens`
+     * would have implied. Set from a model-name effort suffix on the Codex
+     * route (dario#1260, `gpt-5.6-terra:high`), which is the only way an
+     * Anthropic-shape caller can choose an effort the budget thresholds cannot
+     * express. Unset means the existing thinking-derived behaviour, unchanged.
+     */
+    effort?: ResponsesReasoningConfig['effort'];
     /**
      * `store`. Default false — dario is stateless and keeps no server-side
      * conversation. Set true only if a caller wants OpenAI-side retention.

package/dist/anthropic-responses-translate.js

@@ -312,7 +312,17 @@ function translateToolChoice(choice) {
  * client's intended visible-output budget survives on a reasoning model
  * (max_output_tokens caps reasoning + output combined on the Responses API).
  */
-export const REASONING_HEADROOM = { low: 12000, medium: 25000, high: 50000 };
+export const REASONING_HEADROOM = {
+    none: 0, minimal: 6000, low: 12000, medium: 25000, high: 50000,
+    // dario#1260 widened the reachable levels beyond what the thinking-budget
+    // mapping produces. xhigh and max reason MUCH harder — measured through
+    // dario on one identical prompt, same model, only the level changing:
+    // low 1,982 output tokens, high 3,947, max 11,160. Reserve above the trend
+    // rather than on it: under-reserving is the failure this table exists to
+    // prevent (reasoning eats the whole budget, status incomplete, empty turn),
+    // and both values are clamped by RESPONSES_MAX_OUTPUT_CAP anyway.
+    xhigh: 80000, max: 120000,
+};
 /** gpt-5.x / o-series output ceiling (tokens). */
 export const RESPONSES_MAX_OUTPUT_CAP = 128000;
 /**
@@ -376,7 +386,10 @@ export function anthropicToResponsesRequest(body, targetModel, options = {}) {
     if (body.tool_choice?.disable_parallel_tool_use === true && out.tools) {
         out.parallel_tool_calls = false;
     }
-    const effort = thinkingToReasoningEffort(body.thinking);
+    // An explicitly named effort wins over the thinking-budget mapping: the
+    // caller asked for a level, not a budget, and the thresholds cannot express
+    // xhigh or max at all.
+    const effort = options.effort ?? thinkingToReasoningEffort(body.thinking);
     if (effort) {
         out.reasoning = { effort };
         const summary = options.reasoningSummary === undefined ? 'auto' : options.reasoningSummary;

package/dist/codex-backend.d.ts

@@ -1,7 +1,8 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { CodexAccountCredentials } from './codex-accounts.js';
-import { type ResponsesUsage } from './anthropic-responses-translate.js';
+import { type ResponsesReasoningConfig, type ResponsesUsage } from './anthropic-responses-translate.js';
 import { type ModelResolver, type ClaudeTarget } from './claude-model.js';
+import { type EffortValue } from './effort.js';
 export declare const CODEX_BACKEND_BASE_URL: string;
 /**
  * Client version sent on the model-discovery call. The backend REQUIRES the
@@ -72,7 +73,13 @@ export declare function isCodexModel(model: string, slugs: readonly string[]): b
  * own. A single-entry chain keeps the pre-6.0 meaning exactly, so configs
  * written before this release behave identically.
  */
-export declare function pickCodexFallback(models: readonly string[], slugs: readonly string[]): string | null;
+export interface CodexTarget {
+    /** The slug as the account lists it — what goes in the outbound body. */
+    model: string;
+    /** Effort the entry declared through a `:high`-style suffix, if any. */
+    effort?: EffortValue;
+}
+export declare function pickCodexFallback(models: readonly string[], slugs: readonly string[]): CodexTarget | null;
 export declare function pickClaudeFallback(models: readonly string[], slugs: readonly string[], bases?: readonly string[], resolve?: ModelResolver): string | null;
 /**
  * {@link pickClaudeFallback} with the effort the winning entry asked for.
@@ -276,4 +283,10 @@ export declare function buildCodexHeaders(creds: CodexAccountCredentials): Recor
  * testable without network (test/codex-backend.mjs), matching the pattern
  * test/codex-oauth.mjs already uses.
  */
-export declare function forwardToCodex(req: IncomingMessage, res: ServerResponse, body: Buffer, creds: CodexAccountCredentials, corsOrigin: string, securityHeaders: Record<string, string>, upstreamTimeoutMs: number, verbose: boolean, shape?: CodexRequestShape, fetchImpl?: typeof fetch, deferOnUnavailable?: boolean, onDone?: (outcome: CodexForwardOutcome) => void, onDecline?: (info: CodexDecline) => void): Promise<boolean>;
+export declare function forwardToCodex(req: IncomingMessage, res: ServerResponse, body: Buffer, creds: CodexAccountCredentials, corsOrigin: string, securityHeaders: Record<string, string>, upstreamTimeoutMs: number, verbose: boolean, shape?: CodexRequestShape, fetchImpl?: typeof fetch, deferOnUnavailable?: boolean, onDone?: (outcome: CodexForwardOutcome) => void, onDecline?: (info: CodexDecline) => void, 
+/**
+ * Effort named by a model-name suffix (dario#1260). Anthropic-shape only:
+ * a chat/completions caller sets `reasoning_effort` itself and that already
+ * translates. Undefined leaves the request exactly as it was.
+ */
+effort?: ResponsesReasoningConfig['effort']): Promise<boolean>;

package/dist/codex-backend.js

@@ -24,6 +24,7 @@
 import { createHash } from 'node:crypto';
 import { anthropicToResponsesRequest, anthropicUsageFromResponses, createResponsesSSEParser, formatResponsesAnthropicSSE, createAnthropicMessageAssembler, responsesStreamToAnthropicSSE, } from './anthropic-responses-translate.js';
 import { resolveClaudeTarget } from './claude-model.js';
+import { parseEffortSuffix } from './effort.js';
 import { BAKED_BASE_MODELS } from './model-catalog.js';
 import { parseRetryAfterMs } from './provider-cooldown.js';
 export const CODEX_BACKEND_BASE_URL = process.env.DARIO_CODEX_BASE_URL || 'https://chatgpt.com/backend-api/codex';
@@ -121,20 +122,28 @@ export function isCodexModel(model, slugs) {
     const m = model.toLowerCase();
     return slugs.some(s => s.toLowerCase() === m);
 }
-/**
- * A pool-fallback value may name a CHAIN — `gpt-5.6-sol,claude-sonnet-5` — and
- * each provider takes the first entry it can actually serve. These two pickers
- * are the whole selection rule, kept pure so it is testable without a socket.
- *
- * Reading the chain from both ends is what makes failover SYMMETRIC in v6.0.0:
- * `pickCodexFallback` catches a drained Claude pool, `pickClaudeFallback`
- * catches a ChatGPT subscription that is rate-limited or down. Neither
- * subscription hitting its ceiling can take the whole deployment dark on its
- * own. A single-entry chain keeps the pre-6.0 meaning exactly, so configs
- * written before this release behave identically.
- */
 export function pickCodexFallback(models, slugs) {
-    return models.find(m => isCodexModel(m, slugs)) ?? null;
+    for (const m of models) {
+        // The name AS WRITTEN wins, and only a name that matches no slug at all is
+        // re-read as `model:effort` — the same two-pass rule resolveClaudeTarget
+        // uses for chain entries (dario#1161), so a slug that genuinely ends in an
+        // effort word keeps priority over the suffix reading.
+        //
+        // Without the second pass a codex chain entry carrying the very suffix the
+        // Claude half accepts (`gpt-5.6-terra:high`) matched nothing and was
+        // silently SKIPPED: no error, no log, just a failover the operator
+        // configured that never fired (dario#1260).
+        //
+        // Per entry rather than two passes over the whole list, because the chain is
+        // priority-ordered and a full as-written sweep would let a later entry
+        // overtake an earlier one purely for being spelled without a suffix.
+        if (isCodexModel(m, slugs))
+            return { model: m };
+        const eff = parseEffortSuffix(m);
+        if (eff.effort && isCodexModel(eff.model, slugs))
+            return { model: eff.model, effort: eff.effort };
+    }
+    return null;
 }
 export function pickClaudeFallback(models, slugs, bases = BAKED_BASE_MODELS, resolve) {
     // "Not a codex slug" is NOT the same as "the Claude pool can serve it". A
@@ -746,7 +755,13 @@ export function buildCodexHeaders(creds) {
  * 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, shape = 'openai', fetchImpl = fetch, deferOnUnavailable = false, onDone, onDecline) {
+export async function forwardToCodex(req, res, body, creds, corsOrigin, securityHeaders, upstreamTimeoutMs, verbose, shape = 'openai', fetchImpl = fetch, deferOnUnavailable = false, onDone, onDecline, 
+/**
+ * Effort named by a model-name suffix (dario#1260). Anthropic-shape only:
+ * a chat/completions caller sets `reasoning_effort` itself and that already
+ * translates. Undefined leaves the request exactly as it was.
+ */
+effort) {
     void req;
     const isAnthropic = shape === 'anthropic';
     // Reported exactly once, on every exit that answered the client. Without
@@ -789,7 +804,7 @@ export async function forwardToCodex(req, res, body, creds, corsOrigin, security
     const model = String(parsed.model ?? '');
     // stream is forced: the backend is always streamed and collapsed here.
     const upstreamBody = isAnthropic
-        ? { ...anthropicToResponsesRequest(parsed, model), stream: true }
+        ? { ...anthropicToResponsesRequest(parsed, model, effort ? { effort } : {}), stream: true }
         : chatCompletionsToResponses(parsed);
     const scrubbed = toCodexSupportedBody({
         ...upstreamBody,

package/dist/effort.d.ts

@@ -18,6 +18,20 @@
 /** Valid values for the `--effort` flag. Mirrors CC's effort set (`low|medium|high|xhigh|max`) plus CC's `ultracode` mode and dario's pseudo-value `'client'` for passthrough. `'ultracode'` is CC's xhigh-plus-dynamic-workflow-orchestration mode (CC 2.1.154); the Messages API accepts only low|medium|high|xhigh|max, so dario normalizes ultracode → 'xhigh' on the wire (see normalizeEffortForWire). `'client'` passes through the client's own `output_config.effort` (falling back to `'xhigh'`). dario#87, `'max'` added in dario#190, `'ultracode'` added 2026-05-28. */
 export type EffortValue = 'low' | 'medium' | 'high' | 'xhigh' | 'ultracode' | 'max' | 'client';
 export declare const VALID_EFFORT_VALUES: ReadonlyArray<EffortValue>;
+/**
+ * dario's effort tiers onto the levels the Codex Responses backend accepts
+ * (dario#1260). Probed 2026-08-29: `none, minimal, low, medium, high, xhigh,
+ * max` are valid upstream; `ultra` 400s.
+ *
+ *   - low/medium/high/xhigh/max pass through — same name on both sides.
+ *   - `ultracode` is dario's own tier with no upstream equivalent. It maps to
+ *     `max`, the nearest thing the backend has, rather than being dropped:
+ *     a caller who asked for the most effort available should not silently
+ *     get the default.
+ *   - `client` means "whatever the client asked for", so it forces nothing
+ *     and the request's own thinking budget decides, as before.
+ */
+export declare function effortForCodex(effort: EffortValue | undefined): 'low' | 'medium' | 'high' | 'xhigh' | 'max' | undefined;
 export declare function parseEffortSuffix(model: string): {
     model: string;
     effort?: EffortValue;

package/dist/effort.js

@@ -26,6 +26,32 @@ export const VALID_EFFORT_VALUES = ['low', 'medium', 'high', 'xhigh', 'ultracode
  * suffix removed plus the parsed effort (undefined when none). Exported for tests.
  */
 const SUFFIX_EFFORTS = ['ultracode', 'medium', 'xhigh', 'high', 'low', 'max'];
+/**
+ * dario's effort tiers onto the levels the Codex Responses backend accepts
+ * (dario#1260). Probed 2026-08-29: `none, minimal, low, medium, high, xhigh,
+ * max` are valid upstream; `ultra` 400s.
+ *
+ *   - low/medium/high/xhigh/max pass through — same name on both sides.
+ *   - `ultracode` is dario's own tier with no upstream equivalent. It maps to
+ *     `max`, the nearest thing the backend has, rather than being dropped:
+ *     a caller who asked for the most effort available should not silently
+ *     get the default.
+ *   - `client` means "whatever the client asked for", so it forces nothing
+ *     and the request's own thinking budget decides, as before.
+ */
+export function effortForCodex(effort) {
+    switch (effort) {
+        case 'low':
+        case 'medium':
+        case 'high':
+        case 'xhigh':
+        case 'max': return effort;
+        case 'ultracode': return 'max';
+        case 'client':
+        case undefined: return undefined;
+        default: return undefined;
+    }
+}
 export function parseEffortSuffix(model) {
     for (const e of SUFFIX_EFFORTS) {
         for (const sep of [':', '-']) {

package/dist/proxy.js

@@ -23,7 +23,8 @@ import { loadAllAccounts, loadAccount, saveAccount, refreshAccountToken, resyncL
 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 { forwardToCodex, getCodexModelSlugs, peekCodexModelSlugs, isCodexModel, pickCodexFallback, pickClaudeTarget, CODEX_BACKEND_BASE_URL } from './codex-backend.js';
+import { effortForCodex } from './effort.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';
@@ -1945,9 +1946,10 @@ export async function startProxy(opts = {}) {
             return false;
         }
         const slugs = await getCodexModelSlugs(creds).catch(() => []);
-        const fallbackModel = pickCodexFallback(fallbackModels, slugs);
-        if (!fallbackModel)
+        const fallbackPick = pickCodexFallback(fallbackModels, slugs);
+        if (!fallbackPick)
             return false;
+        const fallbackModel = fallbackPick.model;
         const fallbackBody = buildPoolFallbackBody(body, fallbackModel);
         if (!fallbackBody)
             return false;
@@ -1969,7 +1971,12 @@ export async function startProxy(opts = {}) {
         // an outage, not quota — cooling it would park a provider that may be
         // back on the next request, which is the opposite of the fix.
         (d) => { if (d.status === 429)
-            providerCooldowns.note('codex', d.retryAfterMs); });
+            providerCooldowns.note('codex', d.retryAfterMs); }, 
+        // The mirror of the Claude side (dario#1161): an operator who writes
+        // `--pool-fallback=gpt-5.6-terra:high` is choosing the effort the
+        // failover runs at, so the entry's own suffix reaches the request rather
+        // than the failover quietly running at the backend default.
+        effortForCodex(fallbackPick.effort));
         if (served)
             providerCooldowns.clear('codex');
         return served;
@@ -3066,9 +3073,9 @@ export async function startProxy(opts = {}) {
             if (body.length > 0) {
                 try {
                     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;
+                    // Reassignable: the codex effort-suffix strip below rewrites it, and
+                    // every routing decision after that point must see the stripped name.
+                    let rawModel = (peek.model || '').toString();
                     // Credentials are re-read per request (not cached at startup) because
                     // a refresh rotates them on disk; getFreshCodexAccount refreshes when
                     // inside the expiry buffer, collapsing concurrent refreshes per alias.
@@ -3105,6 +3112,43 @@ export async function startProxy(opts = {}) {
                             }
                         }
                     }
+                    // dario#1260 — an effort suffix on a CODEX model (`gpt-5.6-terra:high`).
+                    // The two strip sites further up deliberately leave OpenAI-shaped names
+                    // alone: an openai-compat backend may serve a model whose real id ends
+                    // in `-high`/`-low`, and stripping there would rewrite a legitimate
+                    // name against a catalog this proxy cannot see. Codex is the one
+                    // provider that publishes its routable set, so here — and only here —
+                    // the ambiguity is decidable: strip when the name as written matches no
+                    // slug and the stripped name matches one.
+                    //
+                    // That guard is what makes this strictly additive. The only requests
+                    // whose routing changes are the ones that answer 400 `model_unroutable`
+                    // today, because a name that already routes is never re-read.
+                    //
+                    // Placed HERE rather than beside its siblings because `codexModels` is
+                    // THIS request's account's list, resolved just above; the suffix cannot
+                    // be told apart from a real id without it.
+                    if (rawModel && codexModels.length > 0 && !isCodexModel(rawModel, codexModels)) {
+                        const eff = parseEffortSuffix(rawModel);
+                        if (eff.effort && isCodexModel(eff.model, codexModels)) {
+                            if (verbose)
+                                console.log(`[dario] effort suffix: ${rawModel} → model ${eff.model} (codex, effort: ${eff.effort})`);
+                            requestEffort = eff.effort;
+                            rawModel = eff.model;
+                            // The suffix must not survive into the outbound body: the backend
+                            // 400s on a slug it does not list, which is the very failure this
+                            // fixes. `body` is re-serialized from `parsedBody` exactly as the
+                            // alias and provider-prefix blocks above do.
+                            peek.model = eff.model;
+                            body = Buffer.from(JSON.stringify(parsedBody));
+                        }
+                    }
+                    // Chosen AFTER the strip above, not before it: a per-model fallback
+                    // spec is keyed on the model being routed, and keying it on a name
+                    // still carrying a dario-side effort suffix would miss the operator's
+                    // own entry for that model and fall back to the unscoped chain.
+                    const requestPoolFallbackModels = selectPoolFallbackModels(poolFallbackSpec, rawModel);
+                    const requestPoolFallbackModel = requestPoolFallbackModels[0] ?? null;
                     const decision = routeProvider({
                         isOpenAIPath: isOpenAI,
                         model: rawModel,
@@ -3205,7 +3249,11 @@ export async function startProxy(opts = {}) {
                         // is an outage, and parking a provider for that would keep it out
                         // of the chain while it was already coming back.
                         (d) => { if (d.status === 429)
-                            providerCooldowns.note('codex', d.retryAfterMs); });
+                            providerCooldowns.note('codex', d.retryAfterMs); }, 
+                        // dario#1260 — the effort named by the model-name suffix stripped
+                        // above. Undefined for every request that did not name one, which
+                        // leaves the outbound body exactly as it was.
+                        effortForCodex(requestEffort));
                         if (served) {
                             // A provider that just served is not rate-limited.
                             providerCooldowns.clear('codex');

package/dist/version.js

@@ -1,28 +1,42 @@
 /**
- * dario's own package version, read once from the bundled package.json.
+ * dario's own package version, bound at module load.
  *
  * Surfaced on `/status` and `/health` (#640) so a headless operator can confirm
  * an auto-update actually rolled the running proxy — `curl /health | jq .version`
  * beats exec-ing into the container to read package.json.
+ *
+ * WHY AT MODULE LOAD, NOT ON FIRST CALL. This used to read package.json lazily
+ * the first time someone asked, and cache that. `npm i -g` rewrites
+ * package.json under the running install without touching the process, so a
+ * proxy that had not served `/status` before an upgrade answered its first one
+ * with the NEW version while still executing the OLD code — precisely the
+ * opposite of what the field exists to report. It cost the reporter on #1244 a
+ * round trip: `/status` read 6.0.34 while `GET /admin/accounts` was still
+ * emitting the 6.0.33 field set, so the advice he had been given ("upgrade,
+ * then read `organization_id`") looked already done.
+ *
+ * Reading at import binds the value to the process. proxy.ts imports this at
+ * startup, so `/status` reports the build that is actually answering until it
+ * restarts — the only claim the field can honestly make.
  */
 import { readFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
-let cached = null;
-export function darioVersion() {
-    if (cached !== null)
-        return cached;
-    let v = 'unknown';
+function readVersion() {
     try {
         // dist/version.js → ../package.json (same layout the MCP server + CLI use).
         const here = dirname(fileURLToPath(import.meta.url));
         const pkg = JSON.parse(readFileSync(join(here, '..', 'package.json'), 'utf-8'));
         if (typeof pkg.version === 'string')
-            v = pkg.version;
+            return pkg.version;
     }
     catch {
-        // package.json missing/malformed — keep 'unknown', never throw.
+        // package.json missing/malformed — report 'unknown', never throw.
     }
-    cached = v;
-    return v;
+    return 'unknown';
+}
+/** Read once, at import. See the note above for why not on first call. */
+const VERSION = readVersion();
+export function darioVersion() {
+    return VERSION;
 }

package/docs/configuration.md

@@ -74,6 +74,39 @@ Off by default, each one a deliberate divergence from what real CC sends.
 | `DARIO_EFFORT` | `--effort=` | Forces a reasoning-effort level. Can flip requests to overage billing — watch `-v` logs for representative-claim changes ([`#87`](https://github.com/askalf/dario/issues/87)). |
 | `DARIO_MAX_TOKENS` | `--max-tokens=` | Anthropic enforces the per-model ceiling server-side, so too-high values return a clean 400 ([`#88`](https://github.com/askalf/dario/issues/88)). |
 
+### Per-request effort, by model name
+
+`DARIO_EFFORT` is process-wide: it applies to every caller, Claude and Codex
+alike. A client that has no way to set `output_config.effort` can instead name
+the level in the model itself, and only that request changes:
+
+```
+claude-opus-4-8:high      colon form
+claude-opus-4-8-high      hyphen form, for Cursor, which rewrites colons
+gpt-5.6-terra:high        a Codex model, same two spellings
+```
+
+Levels a suffix may name: `low`, `medium`, `high`, `xhigh`, `max`, and dario's
+own `ultracode`, which reaches a Codex backend as `max`. On the Codex path the
+level is sent as `reasoning.effort`; on the Claude path as
+`output_config.effort`.
+
+`client` is a valid `DARIO_EFFORT` value but deliberately **not** a suffix. It
+means "leave the client's own choice alone", so naming it in a model would be a
+no-op, and accepting it would let a model genuinely named `...-client` be
+stripped to a name the backend does not list.
+
+The suffix is only read when the name as written matches no model the provider
+lists, so a real model id that happens to end in an effort word is routed
+exactly as written and never re-read. A `--pool-fallback` chain entry may carry
+one too, which sets the effort the failover request runs at.
+
+Effort is not free. Measured through dario on one prompt with only the level
+changing: `low` returned 1,982 output tokens in 18s, `high` 3,947 in 35s, and
+`max` 11,160 in 100s. Reasoning is billed as output, so `max` is a real cost
+increase on every request that names it, and on a long agent loop it can push a
+run into its own timeout.
+
 ## Pacing
 
 Only meaningful with stealth, and all default to 0 (off) except the cap. See [`wire-fidelity.md`](./wire-fidelity.md).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "6.0.36",
+  "version": "6.0.38",
   "description": "Use your Claude and ChatGPT subscriptions in Cursor, Cline, Aider, Claude Code and the Agent SDK — at subscription pricing, not per-token API bills. One local Anthropic + OpenAI-compatible endpoint: either plan answers either wire shape, with automatic failover when one hits its limit.",
   "type": "module",
   "bin": {