@askalf/dario 6.0.3 → 6.0.5

package/dist/cc-template.d.ts

@@ -8,6 +8,7 @@
  * action required. See src/live-fingerprint.ts for the capture pipeline.
  */
 import { TemplateData, PLATFORM_ONLY_TOOLS, INTERACTIVE_ONLY_TOOLS, CONFIG_SCOPED_TOOLS } from './live-fingerprint.js';
+import { VALID_EFFORT_VALUES, parseEffortSuffix, type EffortValue } from './effort.js';
 export { PLATFORM_ONLY_TOOLS, INTERACTIVE_ONLY_TOOLS, CONFIG_SCOPED_TOOLS };
 /** The loaded template itself — source, version, capture age, all fields. Startup banners and drift checks read this directly. */
 export declare const CC_TEMPLATE: TemplateData;
@@ -364,13 +365,8 @@ export declare const DEFAULT_MAX_TOKENS = 64000;
  * Sonnet; pinning to 32k silently truncated its output capacity).
  */
 export declare function resolveMaxTokens(flag: number | 'client' | undefined, clientBody: Record<string, unknown>): number;
-/** 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>;
-export declare function parseEffortSuffix(model: string): {
-    model: string;
-    effort?: EffortValue;
-};
+export { VALID_EFFORT_VALUES, parseEffortSuffix };
+export type { EffortValue };
 /**
  * Resolve the outbound `output_config.effort` value.
  *

package/dist/cc-template.js

@@ -8,6 +8,7 @@
  * action required. See src/live-fingerprint.ts for the capture pipeline.
  */
 import { loadTemplate, promptVariantsOf, VARIANT_FAMILIES, PLATFORM_ONLY_TOOLS, INTERACTIVE_ONLY_TOOLS, CONFIG_SCOPED_TOOLS, } from './live-fingerprint.js';
+import { VALID_EFFORT_VALUES, parseEffortSuffix } from './effort.js';
 // Re-exported so existing importers (scripts/capture-and-bake.mjs, the template
 // invariant tests) keep their import site. The definitions live in
 // live-fingerprint.ts because loadTemplate must apply the same superset rule to
@@ -1183,28 +1184,14 @@ export function resolveMaxTokens(flag, clientBody) {
     }
     return flag;
 }
-export const VALID_EFFORT_VALUES = ['low', 'medium', 'high', 'xhigh', 'ultracode', 'max', 'client'];
-/**
- * dario#419 — strip an optional effort suffix off a model name, so OpenAI-compat
- * clients that can't set `output_config.effort` (e.g. Cursor) can choose effort
- * by model name: `opus-4-8:high` (colon) or Cursor-style `claude-opus-4-8-high`
- * (hyphen). Only the wire-valid effort levels are recognized as a suffix — any
- * other trailing token is left as part of the model name, and a bare model that
- * IS an effort word (e.g. just "high") is left alone. Returns the model with the
- * suffix removed plus the parsed effort (undefined when none). Exported for tests.
- */
-const SUFFIX_EFFORTS = ['ultracode', 'medium', 'xhigh', 'high', 'low', 'max'];
-export function parseEffortSuffix(model) {
-    for (const e of SUFFIX_EFFORTS) {
-        for (const sep of [':', '-']) {
-            const tag = sep + e;
-            if (model.length > tag.length && model.endsWith(tag)) {
-                return { model: model.slice(0, -tag.length), effort: e };
-            }
-        }
-    }
-    return { model };
-}
+// The effort vocabulary and the model-name effort suffix live in effort.ts so
+// the pool-fallback classifier can parse the SAME suffix the request path
+// parses without importing this module — claude-model.ts stays decidable over
+// a base set alone, and hand-copying the suffix list there is what would let
+// `claude:opus:high` drift from `opus:high` (dario#1156 review). Re-exported
+// here because proxy.ts, cli.ts and test/effort-flag.mjs import them from
+// cc-template.
+export { VALID_EFFORT_VALUES, parseEffortSuffix };
 /**
  * Normalize an effort value to a wire-valid `output_config.effort`. The
  * Messages API accepts only low|medium|high|xhigh|max. CC's `ultracode` is a

package/dist/claude-model.d.ts

@@ -1,12 +1,29 @@
+import { type EffortValue } from './effort.js';
 /** Maps a bare name to a canonical id, or returns it unchanged. */
 export type ModelResolver = (model: string) => string;
 /**
- * The canonical id the Claude pool would serve `model` as, or null when it
- * cannot serve it. `bases` is the catalog base set — `getCachedBases()` at a
- * call site, a fixture in a test. `resolve` is the alias pipeline; the default
- * knows only catalog family shorthands, so pass the proxy's full resolver
- * (operator aliases + pinned aliases) where one exists.
+ * What the pool would serve a chain entry as: the canonical id, plus the effort
+ * the entry ASKED FOR when it carried a suffix (`claude:opus:high`). Both
+ * halves travel together because the caller needs both — the id goes into the
+ * body, the effort into the outbound `output_config` — and dropping the second
+ * is how `claude:opus:high` reached Anthropic at the pool default (dario#1161).
+ */
+export type ClaudeTarget = {
+    model: string;
+    effort?: EffortValue;
+};
+/**
+ * The id the Claude pool would serve `model` as AND the effort the entry asked
+ * for, or null when the pool cannot serve it. `bases` is the catalog base set —
+ * `getCachedBases()` at a call site, a fixture in a test. `resolve` is the alias
+ * pipeline; the default knows only catalog family shorthands, so pass the
+ * proxy's full resolver (operator aliases + pinned aliases) where one exists.
+ */
+export declare function resolveClaudeTarget(model: string, bases?: readonly string[], resolve?: ModelResolver): ClaudeTarget | null;
+/**
+ * The canonical id alone, for callers that only need to name the model. See
+ * resolveClaudeTarget for the effort half.
  */
 export declare function resolveClaudeServable(model: string, bases?: readonly string[], resolve?: ModelResolver): string | null;
-/** Whether the Claude pool can serve `model`. See resolveClaudeServable. */
+/** Whether the Claude pool can serve `model`. See resolveClaudeTarget. */
 export declare function isClaudeServableModel(model: string, bases?: readonly string[], resolve?: ModelResolver): boolean;

package/dist/claude-model.js

@@ -19,7 +19,10 @@
  *      `--model-alias` values, pinned aliases (`opus48`) and catalog family
  *      shorthands (`opus`, `sonnet1m`) map to a canonical id. The caller
  *      supplies that resolver so classification and forwarding cannot
- *      disagree.
+ *      disagree. The prefix rule applies to the alias TARGET too, since an
+ *      operator alias is written the way a request model is written — see
+ *      stripClaudePrefix. So does the effort suffix (`:high`, `-high`) — see
+ *      servableTarget.
  *   2. VALIDATE the resolved id against the catalog base set. A `claude-`
  *      prefix on its own proves nothing — `claude-sonnet-6` has the prefix and
  *      does not exist — so the id (sans `[1m]`) must be a base the pool can
@@ -35,36 +38,91 @@
  * cold catalog must still admit real ids, and must still refuse typos.
  */
 import { BAKED_BASE_MODELS, resolveAliasAgainst } from './model-catalog.js';
+import { parseEffortSuffix } from './effort.js';
 /** Provider prefixes that force the Claude path (mirrors proxy.ts's PROVIDER_PREFIXES). */
 const CLAUDE_PREFIXES = new Set(['claude', 'anthropic']);
 /**
- * The canonical id the Claude pool would serve `model` as, or null when it
- * cannot serve it. `bases` is the catalog base set — `getCachedBases()` at a
- * call site, a fixture in a test. `resolve` is the alias pipeline; the default
- * knows only catalog family shorthands, so pass the proxy's full resolver
- * (operator aliases + pinned aliases) where one exists.
+ * Strip a Claude-side provider prefix, or refuse the name outright.
+ *
+ * Null on any prefix that isn't `claude:`/`anthropic:` — a recognized
+ * non-Claude prefix is a definite NO, not a fall-through to the name test
+ * (`openai:claude-sonnet-5` is the operator pointing somewhere else on
+ * purpose), and an unrecognized one names a model this pool has no claim on.
+ * `model` is expected already trimmed + lowercased.
  */
-export function resolveClaudeServable(model, bases = BAKED_BASE_MODELS, resolve) {
-    let m = model.trim().toLowerCase();
-    if (!m)
+function stripClaudePrefix(model) {
+    const idx = model.indexOf(':');
+    if (idx <= 0)
+        return model || null;
+    if (!CLAUDE_PREFIXES.has(model.slice(0, idx)))
+        return null;
+    return model.slice(idx + 1) || null;
+}
+/**
+ * One spelling of the target: strip its prefix, run the catalog pass, keep it
+ * only if the result is a base the pool can forward.
+ *
+ * A target that arrived prefixed still holds a shorthand (`claude:opus` →
+ * `opus`), so the catalog pass runs on it. Idempotent for a target already
+ * canonical: resolveAliasAgainst only answers for family shorthands.
+ */
+function servableTarget(target, bases) {
+    const stripped = stripClaudePrefix(target);
+    if (stripped === null)
         return null;
-    const idx = m.indexOf(':');
-    if (idx > 0) {
-        const prefix = m.slice(0, idx);
-        // A recognized non-Claude prefix is a definite NO, not a fall-through to
-        // the name test below — `openai:claude-sonnet-5` is the operator pointing
-        // somewhere else on purpose.
-        if (!CLAUDE_PREFIXES.has(prefix))
-            return null;
-        m = m.slice(idx + 1);
-        if (!m)
-            return null;
-    }
-    const resolved = (resolve ? resolve(m) : (resolveAliasAgainst(m, bases) ?? m)).trim().toLowerCase();
+    const resolved = resolveAliasAgainst(stripped, bases) ?? stripped;
     const base = resolved.endsWith('[1m]') ? resolved.slice(0, -4) : resolved;
     return bases.some((b) => b.toLowerCase() === base) ? resolved : null;
 }
-/** Whether the Claude pool can serve `model`. See resolveClaudeServable. */
+/**
+ * The id the Claude pool would serve `model` as AND the effort the entry asked
+ * for, or null when the pool cannot serve it. `bases` is the catalog base set —
+ * `getCachedBases()` at a call site, a fixture in a test. `resolve` is the alias
+ * pipeline; the default knows only catalog family shorthands, so pass the
+ * proxy's full resolver (operator aliases + pinned aliases) where one exists.
+ */
+export function resolveClaudeTarget(model, bases = BAKED_BASE_MODELS, resolve) {
+    const entry = stripClaudePrefix(model.trim().toLowerCase());
+    if (entry === null)
+        return null;
+    // The alias TARGET may carry a prefix of its own — operator aliases are
+    // declared the way a request model is written, and `--model-alias=backup=
+    // claude:opus` is the natural way to say it (dario#1151). The request path
+    // parses that prefix AFTER alias resolution; without the same pass here the
+    // target reached the base check as the literal `claude:opus`, matched
+    // nothing, and a perfectly valid fallback was skipped.
+    const target = (resolve ? resolve(entry) : (resolveAliasAgainst(entry, bases) ?? entry))
+        .trim().toLowerCase();
+    const direct = servableTarget(target, bases);
+    if (direct)
+        return { model: direct };
+    // …and it may carry an effort suffix as well (`claude:opus:high`,
+    // `claude-opus-4-8-high`), which the request path strips on the Claude side
+    // exactly like this (dario#419, proxy.ts). Without the same pass the suffix
+    // survived into the base check, matched nothing, and the entry was silently
+    // unservable — the prefix fix in #1156 left this half unresolved. Tried only
+    // AFTER the name as written fails, so a real id that happens to end in an
+    // effort word keeps priority over the suffix reading.
+    //
+    // The effort is RETURNED, not discarded: an operator who writes `:high` on a
+    // chain entry is choosing the effort the failover request runs at, and the
+    // request path honours exactly that spelling for a client-sent model. Serving
+    // the failover at the pool default instead would silently answer a `high`
+    // request at whatever `--effort` happens to be (dario#1161).
+    const eff = parseEffortSuffix(target);
+    if (!eff.effort)
+        return null;
+    const stripped = servableTarget(eff.model, bases);
+    return stripped ? { model: stripped, effort: eff.effort } : null;
+}
+/**
+ * The canonical id alone, for callers that only need to name the model. See
+ * resolveClaudeTarget for the effort half.
+ */
+export function resolveClaudeServable(model, bases = BAKED_BASE_MODELS, resolve) {
+    return resolveClaudeTarget(model, bases, resolve)?.model ?? null;
+}
+/** Whether the Claude pool can serve `model`. See resolveClaudeTarget. */
 export function isClaudeServableModel(model, bases = BAKED_BASE_MODELS, resolve) {
-    return resolveClaudeServable(model, bases, resolve) !== null;
+    return resolveClaudeTarget(model, bases, resolve) !== null;
 }

package/dist/codex-backend.d.ts

@@ -23,7 +23,7 @@
  */
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { CodexAccountCredentials } from './codex-accounts.js';
-import { type ModelResolver } from './claude-model.js';
+import { type ModelResolver, type ClaudeTarget } from './claude-model.js';
 export declare const CODEX_BACKEND_BASE_URL: string;
 /**
  * Client version sent on the model-discovery call. The backend REQUIRES the
@@ -87,6 +87,18 @@ export declare function isCodexModel(model: string, slugs: readonly string[]): b
  */
 export declare function pickCodexFallback(models: readonly string[], slugs: readonly string[]): string | 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.
+ *
+ * `claude:opus:high` names BOTH a model and an effort, and the request path
+ * honours exactly that spelling for a client-sent model. Selection kept only
+ * the model half, so a declined codex request configured that way reached the
+ * Claude pool at the pool default effort — the operator's `high` silently
+ * dropped (dario#1161). The caller applies `effort` when it rebuilds the
+ * Claude-bound request; `undefined` means the entry named no effort and the
+ * pool default stands.
+ */
+export declare function pickClaudeTarget(models: readonly string[], slugs: readonly string[], bases?: readonly string[], resolve?: ModelResolver): ClaudeTarget | null;
 /**
  * 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

package/dist/codex-backend.js

@@ -1,5 +1,5 @@
 import { anthropicToResponsesRequest, createResponsesSSEParser, formatResponsesAnthropicSSE, createAnthropicMessageAssembler, responsesStreamToAnthropicSSE, } from './anthropic-responses-translate.js';
-import { resolveClaudeServable } from './claude-model.js';
+import { resolveClaudeTarget } from './claude-model.js';
 import { BAKED_BASE_MODELS } from './model-catalog.js';
 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. */
@@ -133,12 +133,26 @@ export function pickClaudeFallback(models, slugs, bases = BAKED_BASE_MODELS, res
     // Returns the RESOLVED canonical id, not the entry as written: the caller
     // swaps it into the body after the proxy's own alias pass has already run,
     // so an alias returned raw would reach Anthropic unresolved and 400.
+    return pickClaudeTarget(models, slugs, bases, resolve)?.model ?? null;
+}
+/**
+ * {@link pickClaudeFallback} with the effort the winning entry asked for.
+ *
+ * `claude:opus:high` names BOTH a model and an effort, and the request path
+ * honours exactly that spelling for a client-sent model. Selection kept only
+ * the model half, so a declined codex request configured that way reached the
+ * Claude pool at the pool default effort — the operator's `high` silently
+ * dropped (dario#1161). The caller applies `effort` when it rebuilds the
+ * Claude-bound request; `undefined` means the entry named no effort and the
+ * pool default stands.
+ */
+export function pickClaudeTarget(models, slugs, bases = BAKED_BASE_MODELS, resolve) {
     for (const m of models) {
         if (isCodexModel(m, slugs))
             continue;
-        const resolved = resolveClaudeServable(m, bases, resolve);
-        if (resolved)
-            return resolved;
+        const target = resolveClaudeTarget(m, bases, resolve);
+        if (target)
+            return target;
     }
     return null;
 }

package/dist/effort.d.ts

@@ -0,0 +1,24 @@
+/**
+ * effort.ts — the effort vocabulary and the model-name effort suffix.
+ *
+ * These lived in cc-template.ts, which is where the request path uses them.
+ * They moved down here because the pool-fallback classifier (claude-model.ts)
+ * has to parse the SAME suffix the request path parses, and that module is
+ * deliberately pure — it decides what the Claude pool can serve out of a base
+ * set and nothing else. Importing cc-template.js there would drag the CC
+ * template load (live capture / bundled snapshot, read at module init) into a
+ * classifier whose whole value is being decidable without one, and a second
+ * hand-written copy of the suffix list would be the other way to get it: two
+ * definitions of "what counts as an effort suffix" that drift apart silently,
+ * which is exactly the bug this file was extracted to fix (dario#1156 review).
+ *
+ * cc-template.ts re-exports all three, so every existing import site
+ * (proxy.ts, cli.ts, test/effort-flag.mjs) is unchanged.
+ */
+/** 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>;
+export declare function parseEffortSuffix(model: string): {
+    model: string;
+    effort?: EffortValue;
+};

package/dist/effort.js

@@ -0,0 +1,39 @@
+/**
+ * effort.ts — the effort vocabulary and the model-name effort suffix.
+ *
+ * These lived in cc-template.ts, which is where the request path uses them.
+ * They moved down here because the pool-fallback classifier (claude-model.ts)
+ * has to parse the SAME suffix the request path parses, and that module is
+ * deliberately pure — it decides what the Claude pool can serve out of a base
+ * set and nothing else. Importing cc-template.js there would drag the CC
+ * template load (live capture / bundled snapshot, read at module init) into a
+ * classifier whose whole value is being decidable without one, and a second
+ * hand-written copy of the suffix list would be the other way to get it: two
+ * definitions of "what counts as an effort suffix" that drift apart silently,
+ * which is exactly the bug this file was extracted to fix (dario#1156 review).
+ *
+ * cc-template.ts re-exports all three, so every existing import site
+ * (proxy.ts, cli.ts, test/effort-flag.mjs) is unchanged.
+ */
+export const VALID_EFFORT_VALUES = ['low', 'medium', 'high', 'xhigh', 'ultracode', 'max', 'client'];
+/**
+ * dario#419 — strip an optional effort suffix off a model name, so OpenAI-compat
+ * clients that can't set `output_config.effort` (e.g. Cursor) can choose effort
+ * by model name: `opus-4-8:high` (colon) or Cursor-style `claude-opus-4-8-high`
+ * (hyphen). Only the wire-valid effort levels are recognized as a suffix — any
+ * other trailing token is left as part of the model name, and a bare model that
+ * IS an effort word (e.g. just "high") is left alone. Returns the model with the
+ * suffix removed plus the parsed effort (undefined when none). Exported for tests.
+ */
+const SUFFIX_EFFORTS = ['ultracode', 'medium', 'xhigh', 'high', 'low', 'max'];
+export function parseEffortSuffix(model) {
+    for (const e of SUFFIX_EFFORTS) {
+        for (const sep of [':', '-']) {
+            const tag = sep + e;
+            if (model.length > tag.length && model.endsWith(tag)) {
+                return { model: model.slice(0, -tag.length), effort: e };
+            }
+        }
+    }
+    return { model };
+}

package/dist/proxy.js

@@ -20,7 +20,7 @@ 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, pickClaudeFallback, CODEX_BACKEND_BASE_URL } from './codex-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 { route as routeProvider } from './provider-adapter.js';
@@ -2746,8 +2746,10 @@ export async function startProxy(opts = {}) {
                         // operator --model-alias first, then pinned + catalog aliases — so
                         // `backup` or `opus48` in the chain works the way it does on a
                         // request, and the classifier validates the id that would actually
-                        // be forwarded.
-                        const claudeTarget = pickClaudeFallback(poolFallbackModels, codexModels, getCachedBases(), (m) => resolveClaudeAlias(applyModelAlias(m, modelAliases) ?? m));
+                        // be forwarded. The entry's own effort suffix (`claude:opus:high`)
+                        // comes back with it — see the swap below.
+                        const claudeTarget = pickClaudeTarget(poolFallbackModels, codexModels, getCachedBases(), (m) => resolveClaudeAlias(applyModelAlias(m, modelAliases) ?? m));
+                        const claudeTargetModel = claudeTarget?.model ?? null;
                         const canDefer = claudeTarget !== null && pool.size > 0 && !upstreamApiKey;
                         const codexReq = requestCount;
                         const served = await forwardToCodex(req, res, body, codexCreds, corsOrigin, SECURITY_HEADERS, upstreamTimeoutMs, verbose, isOpenAI ? 'openai' : 'anthropic', fetch, canDefer, 
@@ -2780,13 +2782,21 @@ export async function startProxy(opts = {}) {
                         });
                         if (served)
                             return;
-                        const swapped = buildPoolFallbackBody(body, claudeTarget);
+                        const swapped = buildPoolFallbackBody(body, claudeTargetModel);
                         if (!swapped) {
                             res.writeHead(503, { 'Content-Type': 'application/json', ...SECURITY_HEADERS });
                             res.end(JSON.stringify({ error: { type: 'upstream_unavailable', message: 'Codex backend unavailable and the request body could not be re-pointed at the Claude pool.' } }));
                             return;
                         }
-                        console.log(`[dario] #${requestCount} codex unavailable -> claude pool as ${claudeTarget}`);
+                        // An operator who writes `--pool-fallback=gpt-5.6-sol,claude:opus:high`
+                        // is choosing the effort the failover runs at, exactly as a client
+                        // naming `claude:opus:high` on the request is. Selection parsed the
+                        // suffix and then dropped it, so the rebuilt Claude request carried
+                        // the pool default instead (dario#1161). A chain entry with no
+                        // suffix leaves whatever the request itself asked for.
+                        if (claudeTarget?.effort)
+                            requestEffort = claudeTarget.effort;
+                        console.log(`[dario] #${requestCount} codex unavailable -> claude pool as ${claudeTargetModel}${claudeTarget?.effort ? ` (effort: ${claudeTarget.effort})` : ''}`);
                         // Copy so the type matches the ArrayBuffer-backed buffer this
                         // handler threads through (Buffer.concat's), as the other in-place
                         // body rewrites above already do.
@@ -2797,7 +2807,7 @@ export async function startProxy(opts = {}) {
                         // reads as a success, which is the exact bug class this release
                         // spent its whole review budget hunting.
                         parsedBody = null;
-                        res.setHeader('x-dario-pool-fallback', claudeTarget);
+                        res.setHeader('x-dario-pool-fallback', claudeTargetModel);
                         // fall through to Claude's turn below
                     }
                     if (rawModel && openaiBackend && decision.provider === 'openai') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "6.0.3",
+  "version": "6.0.5",
   "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": {