dsh-subscriptions 0.2.0 → 0.2.2

package/lib/providers/claude.js

@@ -4,11 +4,11 @@
  * the Anthropic Messages API with the Claude Code identity headers.
  */
 import { execFileSync } from 'node:child_process';
-import { EMPTY_RESPONSE_CODE, errorChain, LlmAdapter, LlmError, ReasoningEffortId } from '@deepseek-ai/dsh-llm';
-import { hostSupportsImageOffload, IMAGE_OFFLOAD_REQUIRED, requiredImageOffloadCount, resolveImages } from '../translate/resolved.js';
+import { EMPTY_RESPONSE_CODE, errorChain, LlmAdapter, LlmError, ReasoningEffortId, } from '@deepseek-ai/dsh-llm';
+import { hostSupportsImageOffload, IMAGE_OFFLOAD_REQUIRED, requiredImageOffloadCount, resolveImages, } from '../translate/resolved.js';
 import { markMessageCache, streamAnthropic, toAnthropicMessages, toAnthropicSystem, toAnthropicTools, } from '../translate/anthropic.js';
 import { httpLlmError, idleWatchdog, mapFetchFailure, mergeReasoning, ModelCatalogCache, discoverAcrossAccounts, discoverOrRetryAuth, isDiscoveryAborted, isMissingOrInvalidCredential, parseProviderJson, oauthEndpointError, OAuthEndpointError, } from './common.js';
-import { AccountTokenManager, DISCOVERY_TIMEOUT_MS, unionAccountCatalogs } from './accounts.js';
+import { AccountTokenManager, DISCOVERY_TIMEOUT_MS, unionAccountCatalogs, } from './accounts.js';
 import { hostFetch } from '../http.js';
 import { compareVersions } from './npm-cli-version.js';
 import { DEFAULT_RATE_LIMIT_WAIT, DEFAULT_RETRY, earliestReset, jsonBody, resetFromFields, resetInstantFromHeader, subscriptionRetryPolicy, } from './rate-limit.js';
@@ -29,7 +29,12 @@ export const CLAUDE_PREEMPT_MS = 5 * 60_000;
  * Body fields Anthropic uses to name a reset instant, read when the unified
  * headers are absent.
  */
-const CLAUDE_RESET_FIELDS = ['resets_at', 'resetsAt', 'reset_at', 'retry_after'];
+const CLAUDE_RESET_FIELDS = [
+    'resets_at',
+    'resetsAt',
+    'reset_at',
+    'retry_after',
+];
 /**
  * Reads the reset instant of the Anthropic window that rejected a request.
  *
@@ -153,15 +158,24 @@ async function fetchClaudeProfile(accessToken) {
         });
         if (!response.ok)
             return {};
-        const profile = await response.json();
+        const profile = (await response.json());
         const account = typeof profile.account === 'object' && profile.account !== null
             ? profile.account
             : {};
-        const email = profile.emailAddress ?? profile.email ?? account.email_address ?? account.email;
-        const subscription = profile.subscriptionType ?? profile.subscription_type ?? account.subscription_type;
+        const email = profile.emailAddress ??
+            profile.email ??
+            account.email_address ??
+            account.email;
+        const subscription = profile.subscriptionType ??
+            profile.subscription_type ??
+            account.subscription_type;
         return {
-            ...typeof email === 'string' && email.length > 0 ? { emailAddress: email } : {},
-            ...typeof subscription === 'string' && subscription.length > 0 ? { subscriptionType: subscription } : {},
+            ...(typeof email === 'string' && email.length > 0
+                ? { emailAddress: email }
+                : {}),
+            ...(typeof subscription === 'string' && subscription.length > 0
+                ? { subscriptionType: subscription }
+                : {}),
         };
     }
     catch {
@@ -171,7 +185,8 @@ async function fetchClaudeProfile(accessToken) {
 }
 /** Build a session from a token response. */
 async function claudeSession(tokens, fallbackRefreshToken, withProfile) {
-    if (typeof tokens.access_token !== 'string' || tokens.access_token.length === 0) {
+    if (typeof tokens.access_token !== 'string' ||
+        tokens.access_token.length === 0) {
         throw new Error('claude token endpoint returned no access token');
     }
     const refreshToken = tokens.refresh_token ?? fallbackRefreshToken;
@@ -180,7 +195,9 @@ async function claudeSession(tokens, fallbackRefreshToken, withProfile) {
     if (typeof tokens.expires_in !== 'number' || tokens.expires_in <= 0) {
         throw new Error('claude token endpoint returned no usable expiry');
     }
-    const profile = withProfile ? await fetchClaudeProfile(tokens.access_token) : {};
+    const profile = withProfile
+        ? await fetchClaudeProfile(tokens.access_token)
+        : {};
     return {
         accessToken: tokens.access_token,
         refreshToken,
@@ -212,7 +229,7 @@ export async function exchangeClaudeCode(code, verifier, redirectUri, state) {
     });
     if (!response.ok)
         throw await oauthEndpointError(response, 'claude');
-    return claudeSession(await parseProviderJson(response, 'claude token exchange'), undefined, true);
+    return claudeSession((await parseProviderJson(response, 'claude token exchange')), undefined, true);
 }
 /**
  * Refresh a claude session (JSON grant echoing the issued scope).
@@ -232,11 +249,15 @@ export async function refreshClaude(session) {
     });
     if (!response.ok)
         throw await oauthEndpointError(response, 'claude');
-    const next = await claudeSession(await parseProviderJson(response, 'claude token refresh'), session.refreshToken, false);
+    const next = await claudeSession((await parseProviderJson(response, 'claude token refresh')), session.refreshToken, false);
     return {
         ...next,
-        ...session.emailAddress === undefined ? {} : { emailAddress: session.emailAddress },
-        ...session.subscriptionType === undefined ? {} : { subscriptionType: session.subscriptionType },
+        ...(session.emailAddress === undefined
+            ? {}
+            : { emailAddress: session.emailAddress }),
+        ...(session.subscriptionType === undefined
+            ? {}
+            : { subscriptionType: session.subscriptionType }),
     };
 }
 /**
@@ -245,8 +266,8 @@ export async function refreshClaude(session) {
  * @returns true when re-login is the only fix.
  */
 export function isClaudePermanentRefreshError(error) {
-    return error instanceof OAuthEndpointError
-        && (error.oauthCode === 'invalid_grant' || error.oauthCode === 'invalid_token');
+    return (error instanceof OAuthEndpointError &&
+        (error.oauthCode === 'invalid_grant' || error.oauthCode === 'invalid_token'));
 }
 export const CLAUDE_USAGE_URL = 'https://api.anthropic.com/api/oauth/usage';
 /** ISO-8601 or numeric epoch (seconds below 1e10 in magnitude, otherwise ms). */
@@ -261,7 +282,9 @@ function claudeResetsAt(value) {
     else {
         return undefined;
     }
-    return Number.isFinite(parsed) && Number.isFinite(new Date(parsed).getTime()) ? parsed : undefined;
+    return Number.isFinite(parsed) && Number.isFinite(new Date(parsed).getTime())
+        ? parsed
+        : undefined;
 }
 /**
  * Read the observed cedar_ember shape from ItsJazii/pane, not an official
@@ -285,20 +308,28 @@ function claudeResetCredits(value, now) {
         if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
             continue;
         const grant = raw;
-        const { id, resets_total: total, resets_left: left, usable_now: usable, paused } = grant;
+        const { id, resets_total: total, resets_left: left, usable_now: usable, paused, } = grant;
         const expiresAt = claudeResetsAt(grant.ends_at);
-        if (typeof id !== 'string' || id.trim().length === 0
-            || typeof total !== 'number' || !Number.isSafeInteger(total) || total < 1
-            || typeof left !== 'number' || !Number.isSafeInteger(left)
-            || expiresAt === undefined
-            || (usable !== undefined && typeof usable !== 'boolean')
-            || (paused !== undefined && typeof paused !== 'boolean'))
+        if (typeof id !== 'string' ||
+            id.trim().length === 0 ||
+            typeof total !== 'number' ||
+            !Number.isSafeInteger(total) ||
+            total < 1 ||
+            typeof left !== 'number' ||
+            !Number.isSafeInteger(left) ||
+            expiresAt === undefined ||
+            (usable !== undefined && typeof usable !== 'boolean') ||
+            (paused !== undefined && typeof paused !== 'boolean'))
             continue;
         const resetsLeft = Math.max(0, Math.min(left, total));
         if (resetsLeft === 0)
             continue;
-        const claimable = !selected && id === ember.next_grant_id && usable === true
-            && paused !== true && !cooling && expiresAt > now;
+        const claimable = !selected &&
+            id === ember.next_grant_id &&
+            usable === true &&
+            paused !== true &&
+            !cooling &&
+            expiresAt > now;
         if (claimable)
             selected = true;
         credits.push({
@@ -306,33 +337,37 @@ function claudeResetCredits(value, now) {
             expiresAt,
             resetsTotal: total,
             resetsLeft,
-            ...usable === undefined ? {} : { usableNow: usable },
-            ...paused === undefined ? {} : { paused },
+            ...(usable === undefined ? {} : { usableNow: usable }),
+            ...(paused === undefined ? {} : { paused }),
             claimable,
-            ...cooldownUntil === undefined ? {} : { cooldownUntil },
+            ...(cooldownUntil === undefined ? {} : { cooldownUntil }),
         });
     }
     return credits.length > 0 ? credits : undefined;
 }
 /** Claude session and weekly buckets reset as whole five-hour/seven-day windows. */
 function claudeWindowTiming(kind) {
-    return kind === 'session' ? { windowDurationMs: 5 * 60 * 60_000, fixedWindow: true }
-        : kind === 'weekly' ? { windowDurationMs: 7 * 24 * 60 * 60_000, fixedWindow: true } : {};
+    return kind === 'session'
+        ? { windowDurationMs: 5 * 60 * 60_000, fixedWindow: true }
+        : kind === 'weekly'
+            ? { windowDurationMs: 7 * 24 * 60 * 60_000, fixedWindow: true }
+            : {};
 }
 /** Map one legacy `{utilization, resets_at}` bucket; undefined when null or unusable. */
 function claudeLegacyWindow(value, kind, scope) {
     if (typeof value !== 'object' || value === null)
         return undefined;
     const bucket = value;
-    if (typeof bucket.utilization !== 'number' || !Number.isFinite(bucket.utilization))
+    if (typeof bucket.utilization !== 'number' ||
+        !Number.isFinite(bucket.utilization))
         return undefined;
     const resetsAt = claudeResetsAt(bucket.resets_at);
     return {
         kind,
-        ...scope === undefined ? {} : { scope },
+        ...(scope === undefined ? {} : { scope }),
         ...claudeWindowTiming(kind),
         usedPercent: bucket.utilization,
-        ...resetsAt === undefined ? {} : { resetsAt },
+        ...(resetsAt === undefined ? {} : { resetsAt }),
     };
 }
 /** Map the modern `limits` array; empty when absent or carrying nothing usable. */
@@ -348,15 +383,17 @@ function claudeLimitsWindows(value) {
             continue;
         const kind = entry.kind === 'session'
             ? 'session'
-            : entry.kind === 'weekly_all' || entry.kind === 'weekly_scoped' ? 'weekly' : 'other';
+            : entry.kind === 'weekly_all' || entry.kind === 'weekly_scoped'
+                ? 'weekly'
+                : 'other';
         const scope = entry.scope?.model?.display_name;
         const resetsAt = claudeResetsAt(entry.resets_at);
         windows.push({
             kind,
-            ...typeof scope === 'string' && scope.length > 0 ? { scope } : {},
+            ...(typeof scope === 'string' && scope.length > 0 ? { scope } : {}),
             ...claudeWindowTiming(kind),
             usedPercent: entry.percent,
-            ...resetsAt === undefined ? {} : { resetsAt },
+            ...(resetsAt === undefined ? {} : { resetsAt }),
         });
     }
     return windows;
@@ -380,14 +417,14 @@ export async function fetchClaudeUsage(session, fetchFn = hostFetch, signal, cli
     const userAgent = claudeCliUserAgent(await cliVersion());
     const init = {
         headers: {
-            'authorization': `Bearer ${session.accessToken}`,
+            authorization: `Bearer ${session.accessToken}`,
             'anthropic-beta': 'oauth-2025-04-20',
             // Unrecognized clients are aggressively rate-limited on this endpoint,
             // so it presents as the CLI like every other subscription request.
             'user-agent': userAgent,
-            'accept': 'application/json',
+            accept: 'application/json',
         },
-        ...signal === undefined ? {} : { signal },
+        ...(signal === undefined ? {} : { signal }),
     };
     let response = await fetchFn(`${CLAUDE_USAGE_URL}?cedar_ember=1`, init);
     let resetCreditsError;
@@ -398,11 +435,13 @@ export async function fetchClaudeUsage(session, fetchFn = hostFetch, signal, cli
     }
     if (!response.ok)
         throw await oauthEndpointError(response, 'claude usage');
-    const payload = await parseProviderJson(response, 'claude usage');
-    const resetCredits = resetCreditsError === undefined ? claudeResetCredits(payload.cedar_ember, Date.now()) : undefined;
+    const payload = (await parseProviderJson(response, 'claude usage'));
+    const resetCredits = resetCreditsError === undefined
+        ? claudeResetCredits(payload.cedar_ember, Date.now())
+        : undefined;
     const resets = {
-        ...resetCredits === undefined ? {} : { resetCredits },
-        ...resetCreditsError === undefined ? {} : { resetCreditsError },
+        ...(resetCredits === undefined ? {} : { resetCredits }),
+        ...(resetCreditsError === undefined ? {} : { resetCreditsError }),
     };
     const modern = claudeLimitsWindows(payload.limits);
     if (modern.length > 0)
@@ -434,14 +473,17 @@ function claudeReasoning(capabilities) {
     const effort = capabilities?.effort;
     if (effort?.supported !== true)
         return undefined;
-    const efforts = CLAUDE_EFFORT_LEVELS
-        .filter(level => effort[level]?.supported === true)
-        .map(level => ({ id: ReasoningEffortId(level), name: level[0].toUpperCase() + level.slice(1) }));
+    const efforts = CLAUDE_EFFORT_LEVELS.filter((level) => effort[level]?.supported === true).map((level) => ({
+        id: ReasoningEffortId(level),
+        name: level[0].toUpperCase() + level.slice(1),
+    }));
     return efforts.length > 0 ? { efforts } : undefined;
 }
 /** A token limit the endpoint disclosed, or undefined when absent or malformed. */
 function positiveTokenCount(value) {
-    return typeof value === 'number' && Number.isSafeInteger(value) && value > 0 ? value : undefined;
+    return typeof value === 'number' && Number.isSafeInteger(value) && value > 0
+        ? value
+        : undefined;
 }
 /**
  * Fetch the live model catalog from the subscription endpoint. `signal`
@@ -452,17 +494,17 @@ export async function fetchClaudeModels(session, fetchFn = hostFetch, signal, cl
     const userAgent = claudeCliUserAgent(await cliVersion());
     const response = await fetchFn(CLAUDE_MODELS_URL, {
         headers: {
-            'authorization': `Bearer ${session.accessToken}`,
+            authorization: `Bearer ${session.accessToken}`,
             'anthropic-version': '2023-06-01',
             'user-agent': userAgent,
             'anthropic-dangerous-direct-browser-access': 'true',
-            'accept': 'application/json',
+            accept: 'application/json',
         },
-        ...signal === undefined ? {} : { signal },
+        ...(signal === undefined ? {} : { signal }),
     });
     if (!response.ok)
         throw await httpLlmError(response, 'claude models API');
-    const payload = await parseProviderJson(response, 'claude models API');
+    const payload = (await parseProviderJson(response, 'claude models API'));
     if (!Array.isArray(payload.data)) {
         throw new Error('claude models API returned an invalid catalog');
     }
@@ -478,10 +520,10 @@ export async function fetchClaudeModels(session, fetchFn = hostFetch, signal, cl
         return {
             id: m.id,
             name: m.display_name ?? m.id,
-            ...contextWindow === undefined ? {} : { contextWindow },
-            ...maxOutputTokens === undefined ? {} : { maxOutputTokens },
-            ...thinkingType === undefined ? {} : { thinkingType },
-            ...reasoning === undefined ? {} : { reasoning },
+            ...(contextWindow === undefined ? {} : { contextWindow }),
+            ...(maxOutputTokens === undefined ? {} : { maxOutputTokens }),
+            ...(thinkingType === undefined ? {} : { thinkingType }),
+            ...(reasoning === undefined ? {} : { reasoning }),
         };
     });
     if (models.length === 0) {
@@ -496,7 +538,9 @@ export async function fetchClaudeModels(session, fetchFn = hostFetch, signal, cl
 function claudeMaxTokens(configured, disc) {
     const outputLimit = disc?.maxOutputTokens;
     const preferred = configured?.maxTokens ?? outputLimit ?? CLAUDE_DEFAULT_MAX_TOKENS;
-    return outputLimit === undefined ? preferred : Math.min(preferred, outputLimit);
+    return outputLimit === undefined
+        ? preferred
+        : Math.min(preferred, outputLimit);
 }
 /**
  * Anthropic rejects any image edge over 2000px once a request carries many
@@ -530,8 +574,9 @@ const CLAUDE_MODALITIES = ['text', 'image'];
  * @param effort - the reasoning effort, when the model advertises efforts.
  * @param cacheTtl - lifetime of every cache breakpoint; defaults to five minutes.
  * Requests that carry a `purpose` (compaction, session titles) always use five
- * minutes to preserve their existing auxiliary-request behavior. A five-minute
- * mark can still read an entry a one-hour mark wrote.
+ * minutes to preserve their existing auxiliary-request behavior — the override
+ * changes the TTL for ordinary turns only, never the auxiliary floor. A
+ * five-minute mark can still read an entry a one-hour mark wrote.
  * @returns the JSON body to POST.
  */
 export function claudeRequestBody(options, messages, maxTokens, thinking, effort, cacheTtl) {
@@ -546,13 +591,15 @@ export function claudeRequestBody(options, messages, maxTokens, thinking, effort
         max_tokens: maxTokens,
         system: toAnthropicSystem(options.system, messages, ttl),
         messages: anthropicMessages,
-        ...options.tools !== undefined && options.tools.length > 0
+        ...(options.tools !== undefined && options.tools.length > 0
             ? { tools: toAnthropicTools(options.tools) }
-            : {},
-        ...thinking === undefined ? {} : { thinking },
-        ...effort === undefined ? {} : { output_config: { effort } },
+            : {}),
+        ...(thinking === undefined ? {} : { thinking }),
+        ...(effort === undefined ? {} : { output_config: { effort } }),
         stream: true,
-        ...options.sessionId !== undefined ? { metadata: { user_id: String(options.sessionId) } } : {},
+        ...(options.sessionId !== undefined
+            ? { metadata: { user_id: String(options.sessionId) } }
+            : {}),
     };
 }
 /** Claude wire adapter: one instance serves the `claude` provider route. */
@@ -577,7 +624,9 @@ export class ClaudeAdapter extends LlmAdapter {
             this.accountCatalogs.clear();
         else
             this.accountCatalogs.delete(account);
-        if (account === undefined || this.catalogOwner === account || this.catalogOwner === undefined) {
+        if (account === undefined ||
+            this.catalogOwner === account ||
+            this.catalogOwner === undefined) {
             this.catalogOwner = undefined;
             this.catalog.invalidate();
         }
@@ -606,16 +655,16 @@ export class ClaudeAdapter extends LlmAdapter {
         // A named account is looked up alone: its window must not be borrowed
         // from another account's catalog.
         const accounts = account === undefined
-            ? (await this.options.tokens.list()).map(entry => entry.key)
+            ? (await this.options.tokens.list()).map((entry) => entry.key)
             : [account];
         return discoverAcrossAccounts(accounts, async (account) => {
             const catalog = await this.catalogFor(account);
             const models = await catalog.resolve(() => this.fetchCatalog(account));
-            return models?.find(entry => entry.id === model);
+            return models?.find((entry) => entry.id === model);
         });
     }
     staticModels(provider) {
-        return this.options.models.map(model => ({
+        return this.options.models.map((model) => ({
             provider,
             id: model.id,
             name: model.name ?? model.id,
@@ -634,27 +683,30 @@ export class ClaudeAdapter extends LlmAdapter {
         if (pool === undefined)
             return own;
         const extra = await pool.modelsForProvider(provider);
-        const seen = new Set(own.map(model => model.id));
+        const seen = new Set(own.map((model) => model.id));
         // Account pools reuse the catalog row; only configured tiers are extra.
-        return [...own, ...extra.filter(model => !seen.has(model.id))];
+        return [...own, ...extra.filter((model) => !seen.has(model.id))];
     }
     /** The provider's own catalog: union of every account, or one account when named. */
     async listOwnModels(provider, account, signal) {
         if (account === undefined) {
-            const accounts = (await this.options.tokens.list()).map(entry => entry.key);
+            const accounts = (await this.options.tokens.list()).map((entry) => entry.key);
             if (accounts.length === 0)
                 return [];
-            return unionAccountCatalogs(accounts, (key, accountSignal) => this.listOwnModels(provider, key, accountSignal), { timeoutMs: DISCOVERY_TIMEOUT_MS, ...signal === undefined ? {} : { signal } });
+            return unionAccountCatalogs(accounts, (key, accountSignal) => this.listOwnModels(provider, key, accountSignal), {
+                timeoutMs: DISCOVERY_TIMEOUT_MS,
+                ...(signal === undefined ? {} : { signal }),
+            });
         }
-        if (!await this.options.tokens.hasSession(account)) {
+        if (!(await this.options.tokens.hasSession(account))) {
             return [];
         }
         if (!this.options.discovery)
             return this.staticModels(provider);
         const catalog = await this.catalogFor(account);
         try {
-            const models = await discoverOrRetryAuth(force => this.options.tokens.session(account, force), catalog, () => catalog.get(() => this.fetchCatalog(account, signal)));
-            return models.map(model => ({
+            const models = await discoverOrRetryAuth((force) => this.options.tokens.session(account, force), catalog, () => catalog.get(() => this.fetchCatalog(account, signal)));
+            return models.map((model) => ({
                 provider,
                 id: model.id,
                 name: model.name,
@@ -672,7 +724,8 @@ export class ClaudeAdapter extends LlmAdapter {
     }
     async resolveModel(provider, model) {
         const pool = this.options.pool?.();
-        if (pool !== undefined && await pool.owns(provider, model)) {
+        if (pool !== undefined &&
+            (await pool.owns(provider, model))) {
             return pool.resolveModel(provider, model);
         }
         return this.resolveOwnModel(provider, model);
@@ -680,7 +733,7 @@ export class ClaudeAdapter extends LlmAdapter {
     /** Capability resolution of the provider's own models (the pool resolves members here). */
     async resolveOwnModel(provider, model, account) {
         const disc = await this.discovered(model, account);
-        const configured = this.options.models.find(entry => entry.id === model);
+        const configured = this.options.models.find((entry) => entry.id === model);
         const limits = this.contextLimitsFor(disc, configured);
         const reasoning = mergeReasoning(this.options.defaultEffortOf?.(model), disc?.reasoning);
         return {
@@ -688,7 +741,9 @@ export class ClaudeAdapter extends LlmAdapter {
             id: model,
             name: disc?.name ?? configured?.name ?? model,
             inputModalities: configured?.inputModalities ?? CLAUDE_MODALITIES,
-            context: { contextWindow: Math.min(this.options.contextWindowOf?.(model) ?? limits.default, limits.max) },
+            context: {
+                contextWindow: Math.min(this.options.contextWindowOf?.(model) ?? limits.default, limits.max),
+            },
             defaultMaxTokens: claudeMaxTokens(configured, disc),
             ...(reasoning === undefined ? {} : { reasoning }),
         };
@@ -700,11 +755,12 @@ export class ClaudeAdapter extends LlmAdapter {
     }
     /** Account-specific bounds the Settings editor shows next to a model's override input. */
     async contextLimits(model, account) {
-        return this.contextLimitsFor(await this.discovered(model, account), this.options.models.find(entry => entry.id === model));
+        return this.contextLimitsFor(await this.discovered(model, account), this.options.models.find((entry) => entry.id === model));
     }
     async *stream(options) {
         const pool = this.options.pool?.();
-        if (pool !== undefined && await pool.owns(options.provider, options.model)) {
+        if (pool !== undefined &&
+            (await pool.owns(options.provider, options.model))) {
             yield* pool.stream(options);
             return;
         }
@@ -726,13 +782,17 @@ export class ClaudeAdapter extends LlmAdapter {
             if (!response.ok) {
                 throw await httpLlmError(response, 'claude API', {
                     rateLimitReset: claudeRateLimitReset,
-                    ...this.options.onWarn === undefined ? {} : { onWarn: this.options.onWarn },
+                    ...(this.options.onWarn === undefined
+                        ? {}
+                        : { onWarn: this.options.onWarn }),
                 });
             }
             if (response.body === null) {
                 throw new LlmError('claude API returned no response body', EMPTY_RESPONSE_CODE);
             }
-            yield* streamAnthropic(response.body, () => { watchdog.pulse(); });
+            yield* streamAnthropic(response.body, () => {
+                watchdog.pulse();
+            });
         }
         catch (error) {
             throw mapFetchFailure('claude API', error, watchdog, options.signal);
@@ -765,29 +825,32 @@ export class ClaudeAdapter extends LlmAdapter {
             const offloadImages = requiredImageOffloadCount(messages, CLAUDE_REQUEST_IMAGE_BUDGET);
             if (offloadImages > 0) {
                 // The supported 0.1.7-rc.2 floor reads `offloadImages`; older option types lack it.
-                throw new LlmError(`claude request images exceed the ${CLAUDE_REQUEST_IMAGE_BUDGET}-byte base64 budget; `
-                    + `${offloadImages} more oldest image(s) must be offloaded`, IMAGE_OFFLOAD_REQUIRED, { offloadImages });
+                throw new LlmError(`claude request images exceed the ${CLAUDE_REQUEST_IMAGE_BUDGET}-byte base64 budget; ` +
+                    `${offloadImages} more oldest image(s) must be offloaded`, IMAGE_OFFLOAD_REQUIRED, { offloadImages });
             }
         }
         const disc = await this.discovered(options.model);
-        const maxTokens = options.maxTokens
-            ?? claudeMaxTokens(this.options.models.find(entry => entry.id === options.model), disc);
+        const maxTokens = options.maxTokens ??
+            claudeMaxTokens(this.options.models.find((entry) => entry.id === options.model), disc);
         const thinking = this.thinkingParam(disc?.thinkingType, maxTokens);
         const effort = options.reasoningEffort !== undefined && disc?.reasoning !== undefined
             ? String(options.reasoningEffort)
             : undefined;
-        const body = claudeRequestBody(options, messages, maxTokens, thinking, effort, this.options.promptCacheTtl);
+        // Read the Settings override per request: a saved change must apply from
+        // the next turn, and a cached value here would go stale.
+        const cacheTtl = this.options.promptCacheTtlOverride?.() ?? this.options.promptCacheTtl;
+        const body = claudeRequestBody(options, messages, maxTokens, thinking, effort, cacheTtl);
         const cliVersion = await (this.options.resolveCliVersion ?? localClaudeCliVersion)();
         return hostFetch(CLAUDE_API_URL, {
             method: 'POST',
             headers: {
-                'authorization': `Bearer ${session.accessToken}`,
+                authorization: `Bearer ${session.accessToken}`,
                 'anthropic-version': '2023-06-01',
                 'anthropic-beta': CLAUDE_BETA_FLAGS,
                 'user-agent': claudeCliUserAgent(cliVersion),
                 'x-app': 'cli',
                 'anthropic-dangerous-direct-browser-access': 'true',
-                'accept': 'text/event-stream',
+                accept: 'text/event-stream',
                 'content-type': 'application/json',
             },
             body: JSON.stringify(body),

package/lib/providers/codex-client-version.js

@@ -9,9 +9,9 @@ export class CodexClientVersionCache extends NpmCliVersionCache {
             url: CODEX_VERSION_URL,
             label: 'Codex',
             floor: () => ({ version: CODEX_CLIENT_VERSION, source: 'fallback' }),
-            ...fetchFn === undefined ? {} : { fetchFn },
-            ...now === undefined ? {} : { now },
-            ...timeoutMs === undefined ? {} : { timeoutMs },
+            ...(fetchFn === undefined ? {} : { fetchFn }),
+            ...(now === undefined ? {} : { now }),
+            ...(timeoutMs === undefined ? {} : { timeoutMs }),
         });
     }
 }