dsh-subscriptions 0.1.5 → 0.2.2

package/lib/providers/pool-health.js

@@ -9,7 +9,7 @@
  * cooldown (transport blips say nothing about the account), or rethrow
  * (the request itself is at fault and another account would fail alike).
  */
-import { CONTEXT_WINDOW_EXCEEDED_CODE, LlmError, QUOTA_EXCEEDED_CODE } from '@deepseek-ai/dsh-llm';
+import { CONTEXT_WINDOW_EXCEEDED_CODE, LlmError, QUOTA_EXCEEDED_CODE, } from '@deepseek-ai/dsh-llm';
 /** Registry key for one pool member. */
 export function memberKey(provider, account, model) {
     return `${provider}/${account}/${model}`;
@@ -33,7 +33,10 @@ export const TRANSIENT_COOLDOWN_MS = 60_000;
  * wall means its siblings on the SAME account would too, so the cooldown
  * parks the account (other accounts of the provider are unaffected).
  */
-const MODEL_SCOPED_QUOTA_PROVIDERS = new Set(['claude', 'antigravity']);
+const MODEL_SCOPED_QUOTA_PROVIDERS = new Set([
+    'claude',
+    'antigravity',
+]);
 /** The `retry-after` an adapter propagated through `httpLlmError`, when any. */
 function retryAfterMs(error) {
     return error.failure.providerRetryAfterMs;
@@ -61,16 +64,28 @@ export function classifyPoolFailure(error, provider) {
                 action: 'switch',
                 cooldownMs: retryAfterMs(error) ?? DEFAULT_QUOTA_COOLDOWN_MS,
                 reason: error.code,
-                scope: MODEL_SCOPED_QUOTA_PROVIDERS.has(provider) ? 'member' : 'account',
+                scope: MODEL_SCOPED_QUOTA_PROVIDERS.has(provider)
+                    ? 'member'
+                    : 'account',
             };
         case 'AUTH':
         case 'INVALID_CREDENTIAL':
         case 'MISSING_CREDENTIAL':
-            return { action: 'switch', cooldownMs: AUTH_COOLDOWN_MS, reason: error.code, scope: 'account' };
+            return {
+                action: 'switch',
+                cooldownMs: AUTH_COOLDOWN_MS,
+                reason: error.code,
+                scope: 'account',
+            };
         case 'SERVER':
         case 'TIMEOUT':
         case 'EMPTY_RESPONSE':
-            return { action: 'switch', cooldownMs: TRANSIENT_COOLDOWN_MS, reason: error.code, scope: 'member' };
+            return {
+                action: 'switch',
+                cooldownMs: TRANSIENT_COOLDOWN_MS,
+                reason: error.code,
+                scope: 'member',
+            };
         case 'TRANSPORT':
             return { action: 'switch' };
         case 'HTTP_402':
@@ -78,7 +93,12 @@ export function classifyPoolFailure(error, provider) {
             // Plan/model availability is account-shaped: another account of the
             // same subscription may still serve. A 400 that is not a context-window
             // error stays HTTP_400 and throws (the request itself is at fault).
-            return { action: 'switch', cooldownMs: TRANSIENT_COOLDOWN_MS, reason: error.code, scope: 'member' };
+            return {
+                action: 'switch',
+                cooldownMs: TRANSIENT_COOLDOWN_MS,
+                reason: error.code,
+                scope: 'member',
+            };
         case CONTEXT_WINDOW_EXCEEDED_CODE:
         case 'ABORTED':
         default:
@@ -94,8 +114,8 @@ export class PoolHealthRegistry {
     records = new Map();
     /** Whether a member may serve: neither it nor its whole account is cooling. */
     isMemberAvailable(provider, account, model, now = Date.now()) {
-        return this.isAvailable(accountKey(provider, account), now)
-            && this.isAvailable(memberKey(provider, account, model), now);
+        return (this.isAvailable(accountKey(provider, account), now) &&
+            this.isAvailable(memberKey(provider, account, model), now));
     }
     /** Whether one registry key is clear right now. */
     isAvailable(key, now = Date.now()) {

package/lib/providers/pool-usage.js

@@ -102,7 +102,8 @@ export class PoolUsageTracker {
             return { supported: false };
         const key = `${provider}/${account}`;
         const entry = this.entries.get(key);
-        if (entry !== undefined && Date.now() - entry.at < (entry.cooldownMs ?? this.ttlMs)) {
+        if (entry !== undefined &&
+            Date.now() - entry.at < (entry.cooldownMs ?? this.ttlMs)) {
             if (entry.snapshot !== undefined) {
                 if (!force)
                     return entry.snapshot;
@@ -178,29 +179,33 @@ export class PoolUsageTracker {
             // fetch fails late and would otherwise cache a cooldown over a fresher
             // success that already landed.
             const sequence = ++this.nextSequence;
-            pending = fetcher().then((value) => {
+            pending = fetcher()
+                .then((value) => {
                 const at = Date.now();
                 const snapshot = { ...value, observedAt: at, stale: false };
                 // An invalidate() during the fetch means this result describes a world
                 // that has moved on; caching it would resurrect the old numbers.
-                if ((this.generation.get(key) ?? 0) === generation && (this.lastWritten.get(key) ?? 0) < sequence) {
+                if ((this.generation.get(key) ?? 0) === generation &&
+                    (this.lastWritten.get(key) ?? 0) < sequence) {
                     this.lastWritten.set(key, sequence);
                     this.entries.set(key, { snapshot, at });
                 }
                 return snapshot;
             }, (error) => {
-                if (!isMissingOrInvalidCredential(error) && (this.generation.get(key) ?? 0) === generation
-                    && (this.lastWritten.get(key) ?? 0) < sequence) {
+                if (!isMissingOrInvalidCredential(error) &&
+                    (this.generation.get(key) ?? 0) === generation &&
+                    (this.lastWritten.get(key) ?? 0) < sequence) {
                     this.lastWritten.set(key, sequence);
                     this.entries.set(key, {
                         error,
                         at: Date.now(),
                         cooldownMs: cooldownFor(error, this.ttlMs),
-                        ...lastSnapshot === undefined ? {} : { lastSnapshot },
+                        ...(lastSnapshot === undefined ? {} : { lastSnapshot }),
                     });
                 }
                 throw error;
-            }).finally(() => {
+            })
+                .finally(() => {
                 // Only clear our own slot: an invalidate may have replaced it.
                 if (this.inflight.get(key) === pending)
                     this.inflight.delete(key);
@@ -211,7 +216,7 @@ export class PoolUsageTracker {
     }
     /** Score one member against a snapshot's windows. */
     score(member, entry) {
-        const windows = (entry.snapshot.windows ?? []).filter(window => windowApplies(window, member.model));
+        const windows = (entry.snapshot.windows ?? []).filter((window) => windowApplies(window, member.model));
         let available = true;
         let urgency = 0;
         for (const window of windows) {
@@ -235,7 +240,9 @@ function degradedQuota(error) {
 }
 /** How long to hold a failure in the negative cache: the endpoint's own `retry-after`, or the default TTL. */
 function cooldownFor(error, defaultTtlMs) {
-    return error instanceof OAuthEndpointError && error.retryAfterMs !== undefined ? error.retryAfterMs : defaultTtlMs;
+    return error instanceof OAuthEndpointError && error.retryAfterMs !== undefined
+        ? error.retryAfterMs
+        : defaultTtlMs;
 }
 /**
  * Whether a window constrains this model: unscoped windows always do; a

package/lib/providers/pool.d.ts

@@ -105,6 +105,14 @@ export declare class PoolAdapter extends LlmAdapter {
     private select;
     /** Pin the serving member to the session (with bounded memory). */
     private remember;
+    /**
+     * Build the terminal exhaustion error and log it. Per-member failovers are
+     * already warned above; without this line dsh.log shows the failover chain
+     * but not the exhaustion that ends it. The message carries only the
+     * LlmError's own sanitized text and code — raw provider payloads never
+     * reach here (see the note in {@link exhausted}).
+     */
+    private exhaustedWithWarn;
     /** Report attempt failures or this pool's active cooldowns, never unrelated health records. */
     private exhausted;
 }

package/lib/providers/pool.js

@@ -9,7 +9,7 @@
  */
 import { EMPTY_RESPONSE_CODE, LlmAdapter, LlmError, QUOTA_EXCEEDED_CODE, } from '@deepseek-ai/dsh-llm';
 import { poolKey } from './pool-family.js';
-import { accountKey, classifyPoolFailure, memberKey, PoolHealthRegistry } from './pool-health.js';
+import { accountKey, classifyPoolFailure, memberKey, PoolHealthRegistry, } from './pool-health.js';
 import { streamAccountWithReplay } from './replay.js';
 /** Bound on sticky-session memory; oldest entries evict past it. */
 const STICKY_SESSION_LIMIT = 1000;
@@ -57,7 +57,7 @@ export class PoolAdapter extends LlmAdapter {
     usable(pools) {
         const result = new Map(pools);
         for (const [id, definition] of [...result]) {
-            const kept = definition.members.filter(member => this.options.adapters[member.provider] !== undefined);
+            const kept = definition.members.filter((member) => this.options.adapters[member.provider] !== undefined);
             if (kept.length === 0)
                 result.delete(id);
             else if (kept.length < definition.members.length)
@@ -118,7 +118,9 @@ export class PoolAdapter extends LlmAdapter {
                 provider,
                 id,
                 name: definition.name ?? id,
-                ...definition.description === undefined ? {} : { description: definition.description },
+                ...(definition.description === undefined
+                    ? {}
+                    : { description: definition.description }),
             });
         }
         return models;
@@ -139,7 +141,7 @@ export class PoolAdapter extends LlmAdapter {
         const seen = new Set();
         const resolved = [];
         for (const member of members) {
-            const requested = member.account ?? await this.options.defaultAccount(member.provider);
+            const requested = member.account ?? (await this.options.defaultAccount(member.provider));
             if (requested === undefined)
                 continue;
             const account = await (this.options.resolveAccount?.(member.provider, requested) ?? Promise.resolve(requested));
@@ -177,28 +179,38 @@ export class PoolAdapter extends LlmAdapter {
             }
             catch (error) {
                 lastFailure = error;
-                this.warnOnce(`pool "${model}": member ${memberLabel(member)} failed to resolve`
-                    + ` (${error instanceof Error ? error.message : String(error)}); excluding it`);
+                this.warnOnce(`pool "${model}": member ${memberLabel(member)} failed to resolve` +
+                    ` (${error instanceof Error ? error.message : String(error)}); excluding it`);
             }
         }
         if (resolved.length === 0) {
             throw new LlmError(`pool "${model}" has no usable member`, 'NO_ADAPTER', {
-                ...lastFailure === undefined ? {} : { cause: lastFailure },
+                ...(lastFailure === undefined ? {} : { cause: lastFailure }),
             });
         }
-        const contextWindows = resolved.map(info => info.context?.contextWindow).filter(isNumber);
-        const maxTokens = resolved.map(info => info.defaultMaxTokens).filter(isNumber);
+        const contextWindows = resolved
+            .map((info) => info.context?.contextWindow)
+            .filter(isNumber);
+        const maxTokens = resolved
+            .map((info) => info.defaultMaxTokens)
+            .filter(isNumber);
         const reasoning = intersectReasoning(resolved);
         const modalities = intersectModalities(resolved);
         return {
             provider,
             id: model,
             name: definition.name ?? model,
-            ...definition.description === undefined ? {} : { description: definition.description },
-            ...contextWindows.length > 0 ? { context: { contextWindow: Math.min(...contextWindows) } } : {},
-            ...maxTokens.length > 0 ? { defaultMaxTokens: Math.min(...maxTokens) } : {},
-            ...reasoning === undefined ? {} : { reasoning },
-            ...modalities === undefined ? {} : { inputModalities: modalities },
+            ...(definition.description === undefined
+                ? {}
+                : { description: definition.description }),
+            ...(contextWindows.length > 0
+                ? { context: { contextWindow: Math.min(...contextWindows) } }
+                : {}),
+            ...(maxTokens.length > 0
+                ? { defaultMaxTokens: Math.min(...maxTokens) }
+                : {}),
+            ...(reasoning === undefined ? {} : { reasoning }),
+            ...(modalities === undefined ? {} : { inputModalities: modalities }),
         };
     }
     /**
@@ -214,7 +226,7 @@ export class PoolAdapter extends LlmAdapter {
         const members = await this.concrete(definition.members);
         const candidates = await this.select(options.model, members, options.sessionId);
         if (candidates.length === 0)
-            throw this.exhausted(options.model, members);
+            throw this.exhaustedWithWarn(options.model, members);
         const failures = [];
         for (const member of candidates) {
             const adapter = this.options.adapters[member.provider];
@@ -239,12 +251,13 @@ export class PoolAdapter extends LlmAdapter {
                     // A quota failure invalidates the cached usage snapshot so the NEXT
                     // selection re-polls instead of trusting minutes-old percentages.
                     // Transient/auth failures say nothing about quota — keep the cache.
-                    if (classification.reason === QUOTA_EXCEEDED_CODE || classification.reason === 'RATE_LIMIT') {
+                    if (classification.reason === QUOTA_EXCEEDED_CODE ||
+                        classification.reason === 'RATE_LIMIT') {
                         this.options.usage.invalidate(member.provider, member.account);
                     }
                 }
-                this.options.onWarn(`pool "${options.model}": ${memberLabel(member)} failed before any output`
-                    + ` (${error instanceof Error ? error.message : String(error)}); trying the next member`);
+                this.options.onWarn(`pool "${options.model}": ${memberLabel(member)} failed before any output` +
+                    ` (${error instanceof Error ? error.message : String(error)}); trying the next member`);
                 failures.push(error);
                 continue;
             }
@@ -271,7 +284,7 @@ export class PoolAdapter extends LlmAdapter {
             }
             return;
         }
-        throw this.exhausted(options.model, members, failures);
+        throw this.exhaustedWithWarn(options.model, members, failures);
     }
     /**
      * Order the candidates for one request. Health filters both strategies;
@@ -282,27 +295,29 @@ export class PoolAdapter extends LlmAdapter {
      * `switchMargin`.
      */
     async select(poolId, members, sessionId) {
-        const usable = members.filter(member => this.options.adapters[member.provider] !== undefined
-            && this.options.health.isMemberAvailable(member.provider, member.account, member.model));
+        const usable = members.filter((member) => this.options.adapters[member.provider] !== undefined &&
+            this.options.health.isMemberAvailable(member.provider, member.account, member.model));
         if (usable.length === 0)
             return [];
         const stickyMember = sessionId === undefined
             ? undefined
-            : usable.find(member => memberKey(member.provider, member.account, member.model) === this.sticky.get(stickyKey(poolId, sessionId)));
+            : usable.find((member) => memberKey(member.provider, member.account, member.model) ===
+                this.sticky.get(stickyKey(poolId, sessionId)));
         if (this.options.strategy === 'priority') {
             return stickyMember === undefined
                 ? usable
-                : [stickyMember, ...usable.filter(member => member !== stickyMember)];
+                : [stickyMember, ...usable.filter((member) => member !== stickyMember)];
         }
         const quotas = new Map(await Promise.all(usable.map(async (member) => [member, await this.options.usage.quotaFor(member)])));
-        const scored = usable.filter(member => quotas.get(member)?.available === true);
-        const quotaFull = usable.filter(member => quotas.get(member)?.available === false);
+        const scored = usable.filter((member) => quotas.get(member)?.available === true);
+        const quotaFull = usable.filter((member) => quotas.get(member)?.available === false);
         scored.sort((a, b) => (quotas.get(b)?.urgency ?? 0) - (quotas.get(a)?.urgency ?? 0));
         if (stickyMember !== undefined && scored.includes(stickyMember)) {
             const best = scored[0];
             const stickyUrgency = quotas.get(stickyMember)?.urgency ?? 0;
             const bestUrgency = quotas.get(best)?.urgency ?? 0;
-            if (best === stickyMember || bestUrgency <= stickyUrgency * this.options.switchMargin) {
+            if (best === stickyMember ||
+                bestUrgency <= stickyUrgency * this.options.switchMargin) {
                 // Sticky holds (no challenger beats it by the margin): lead with it.
                 scored.splice(scored.indexOf(stickyMember), 1);
                 scored.unshift(stickyMember);
@@ -323,6 +338,18 @@ export class PoolAdapter extends LlmAdapter {
         }
         this.sticky.set(key, memberKey(member.provider, member.account, member.model));
     }
+    /**
+     * Build the terminal exhaustion error and log it. Per-member failovers are
+     * already warned above; without this line dsh.log shows the failover chain
+     * but not the exhaustion that ends it. The message carries only the
+     * LlmError's own sanitized text and code — raw provider payloads never
+     * reach here (see the note in {@link exhausted}).
+     */
+    exhaustedWithWarn(model, pool, failures = []) {
+        const error = this.exhausted(model, pool, failures);
+        this.options.onWarn(`pool "${model}": exhausted (${error.code}: ${error.message})`);
+        return error;
+    }
     /** Report attempt failures or this pool's active cooldowns, never unrelated health records. */
     exhausted(model, pool, failures = []) {
         if (pool.length === 0) {
@@ -336,7 +363,7 @@ export class PoolAdapter extends LlmAdapter {
         const recovery = this.options.health.earliestRecovery(keys);
         const retryAfterMs = recovery === undefined ? undefined : Math.max(recovery - Date.now(), 1);
         const coolingReasons = this.options.health.unavailableReasons(keys);
-        const codes = [...failures.map(error => error.code), ...coolingReasons];
+        const codes = [...failures.map((error) => error.code), ...coolingReasons];
         if (codes.length === 0)
             return new LlmError(`pool "${model}" has no usable member`, 'NO_ADAPTER');
         const quotaOnly = codes.every(isQuotaFailure);
@@ -352,15 +379,22 @@ export class PoolAdapter extends LlmAdapter {
             // Keep the error object itself. LlmError freezes its facts snapshot, so
             // replace that snapshot to correct only providerRetryAfterMs for pool
             // routing; this is not permission to rewrite other frozen failure facts.
-            if (retryAfterMs !== undefined && retryAfterMs !== failure.failure.providerRetryAfterMs) {
+            if (retryAfterMs !== undefined &&
+                retryAfterMs !== failure.failure.providerRetryAfterMs) {
                 Object.defineProperty(failure, 'failure', {
-                    value: Object.freeze({ ...failure.failure, providerRetryAfterMs: retryAfterMs }),
+                    value: Object.freeze({
+                        ...failure.failure,
+                        providerRetryAfterMs: retryAfterMs,
+                    }),
                 });
             }
             return failure;
         }
-        const attemptedCodes = failures.map(error => error.code);
-        const details = [...attemptedCodes, ...coolingReasons.filter(code => !attemptedCodes.includes(code))];
+        const attemptedCodes = failures.map((error) => error.code);
+        const details = [
+            ...attemptedCodes,
+            ...coolingReasons.filter((code) => !attemptedCodes.includes(code)),
+        ];
         const summary = failureSummary(details);
         const cause = failures.length === 0
             ? undefined
@@ -377,11 +411,13 @@ export class PoolAdapter extends LlmAdapter {
         // merely because the last member hit its quota. No new aggregate error code.
         const code = quotaOnly
             ? 'RATE_LIMIT'
-            : attemptedCodes.filter(code => !isQuotaFailure(code)).at(-1)
-                ?? coolingReasons.filter(code => !isQuotaFailure(code)).at(-1);
+            : (attemptedCodes.filter((code) => !isQuotaFailure(code)).at(-1) ??
+                coolingReasons.filter((code) => !isQuotaFailure(code)).at(-1));
         return new LlmError(message, code, {
-            ...retryAfterMs === undefined ? {} : { providerRetryAfterMs: retryAfterMs },
-            ...cause === undefined ? {} : { cause },
+            ...(retryAfterMs === undefined
+                ? {}
+                : { providerRetryAfterMs: retryAfterMs }),
+            ...(cause === undefined ? {} : { cause }),
         });
     }
 }
@@ -404,9 +440,11 @@ function failureSummary(codes) {
         RATE_LIMIT: 'provider rate limit reached',
     };
     const limit = 5;
-    const shown = codes.slice(0, limit).map(code => {
+    const shown = codes.slice(0, limit).map((code) => {
         const description = descriptions[code];
-        return description === undefined ? 'member unavailable' : `${code}: ${description}`;
+        return description === undefined
+            ? 'member unavailable'
+            : `${code}: ${description}`;
     });
     if (codes.length > limit)
         shown.push(`${codes.length - limit} more`);
@@ -423,21 +461,22 @@ function intersectReasoning(resolved) {
     const [first, ...rest] = resolved;
     if (first?.reasoning === undefined)
         return undefined;
-    const efforts = first.reasoning.efforts.filter(effort => rest.every(info => info.reasoning?.efforts.some(other => other.id === effort.id) === true));
+    const efforts = first.reasoning.efforts.filter((effort) => rest.every((info) => info.reasoning?.efforts.some((other) => other.id === effort.id) ===
+        true));
     if (efforts.length === 0)
         return undefined;
-    const defaultEffort = first.reasoning.defaultEffort !== undefined
-        && efforts.some(effort => effort.id === first.reasoning?.defaultEffort)
+    const defaultEffort = first.reasoning.defaultEffort !== undefined &&
+        efforts.some((effort) => effort.id === first.reasoning?.defaultEffort)
         ? first.reasoning.defaultEffort
         : undefined;
-    return { efforts, ...defaultEffort === undefined ? {} : { defaultEffort } };
+    return { efforts, ...(defaultEffort === undefined ? {} : { defaultEffort }) };
 }
 /** Modalities all members accept; undefined when any member leaves it unknown. */
 function intersectModalities(resolved) {
     const [first, ...rest] = resolved;
     if (first?.inputModalities === undefined)
         return undefined;
-    const modalities = first.inputModalities.filter(modality => rest.every(info => info.inputModalities?.includes(modality) === true));
+    const modalities = first.inputModalities.filter((modality) => rest.every((info) => info.inputModalities?.includes(modality) === true));
     // An empty intersection would declare negative capability ("accepts
     // nothing"); report unknown instead — the serving member enforces its own
     // limits at request time.

package/lib/providers/rate-limit.js

@@ -67,7 +67,12 @@ export function durationMs(text) {
     // Sticky: every component must abut the previous one, so trailing or
     // interleaved junk ("6m0s later") fails the length check below.
     const pattern = /(\d+(?:\.\d+)?)(ms|h|m|s)/y;
-    const units = { h: 3_600_000, m: 60_000, s: 1_000, ms: 1 };
+    const units = {
+        h: 3_600_000,
+        m: 60_000,
+        s: 1_000,
+        ms: 1,
+    };
     let total = 0;
     let matched = false;
     // A failed sticky exec resets `lastIndex` to zero, so the reached offset is
@@ -191,7 +196,8 @@ export function resetFromFields(value, keys, now, depth = MAX_BODY_DEPTH) {
         return undefined;
     let earliest;
     const consider = (candidate) => {
-        if (candidate !== undefined && (earliest === undefined || candidate < earliest))
+        if (candidate !== undefined &&
+            (earliest === undefined || candidate < earliest))
             earliest = candidate;
     };
     if (Array.isArray(value)) {

package/lib/providers/replay.js

@@ -3,25 +3,37 @@ const REPLAY_KIND = 'subscriptions-account-replay';
 /** Bind opaque replay to the concrete account/model behind a route alias. */
 export async function* streamAccountWithReplay(adapter, options, account, model = options.model) {
     const key = createHash('sha256')
-        .update(JSON.stringify([options.provider, account, model])).digest('hex');
-    const messages = options.messages.map(message => {
-        if (message.role !== 'assistant'
-            || message.source?.replayState === undefined)
+        .update(JSON.stringify([options.provider, account, model]))
+        .digest('hex');
+    const messages = options.messages.map((message) => {
+        if (message.role !== 'assistant' ||
+            message.source?.replayState === undefined)
             return message;
         const source = message.source;
-        if (source.replayState === null || typeof source.replayState !== 'object'
-            || !('response' in source.replayState))
+        if (source.replayState === null ||
+            typeof source.replayState !== 'object' ||
+            !('response' in source.replayState))
             return message;
         const replay = source.replayState;
         const response = replay.response;
-        if (response !== null && typeof response === 'object'
-            && 'kind' in response && response.kind === REPLAY_KIND) {
-            if ('version' in response && response.version === 1
-                && 'key' in response && response.key === key && 'state' in response) {
-                return { ...message, source: {
-                        ...source, provider: options.provider, model,
+        if (response !== null &&
+            typeof response === 'object' &&
+            'kind' in response &&
+            response.kind === REPLAY_KIND) {
+            if ('version' in response &&
+                response.version === 1 &&
+                'key' in response &&
+                response.key === key &&
+                'state' in response) {
+                return {
+                    ...message,
+                    source: {
+                        ...source,
+                        provider: options.provider,
+                        model,
                         replayState: { ...replay, response: response.state },
-                    } };
+                    },
+                };
             }
             const { replayState: _discarded, ...withoutReplay } = source;
             return { ...message, source: withoutReplay };
@@ -37,12 +49,23 @@ export async function* streamAccountWithReplay(adapter, options, account, model
         return { ...message, source: withoutReplay };
     });
     for await (const chunk of adapter.streamAccount({
-        ...options, model, messages,
+        ...options,
+        model,
+        messages,
     }, account)) {
         if (chunk.type === 'finish' && chunk.replayState !== undefined) {
-            yield { ...chunk, replayState: { ...chunk.replayState, response: {
-                        kind: REPLAY_KIND, version: 1, key, state: chunk.replayState.response,
-                    } } };
+            yield {
+                ...chunk,
+                replayState: {
+                    ...chunk.replayState,
+                    response: {
+                        kind: REPLAY_KIND,
+                        version: 1,
+                        key,
+                        state: chunk.replayState.response,
+                    },
+                },
+            };
         }
         else
             yield chunk;

package/lib/providers/reset-redemption.js

@@ -34,9 +34,12 @@ export class ResetRedemption {
         this.canonical = canonical;
     }
     eligible(usage) {
-        const weekly = usage.windows?.find(w => w.kind === 'weekly' && w.scope === undefined);
-        if (!weekly || !Number.isFinite(weekly.usedPercent) || weekly.usedPercent < 80
-            || weekly.resetsAt === undefined || weekly.resetsAt <= Date.now()) {
+        const weekly = usage.windows?.find((w) => w.kind === 'weekly' && w.scope === undefined);
+        if (!weekly ||
+            !Number.isFinite(weekly.usedPercent) ||
+            weekly.usedPercent < 80 ||
+            weekly.resetsAt === undefined ||
+            weekly.resetsAt <= Date.now()) {
             throw new Error('Reset blocked: fresh weekly usage must be at least 80%.');
         }
         if (usage.resetCreditsError)
@@ -54,7 +57,8 @@ export class ResetRedemption {
         if (this.busy.has(who) || this.uncertain.has(who))
             throw new Error('Reset blocked: an operation is pending or its outcome is uncertain. Check Codex before retrying.');
         const weeklyUsedPercent = this.eligible(usage);
-        const credit = usage.resetCredits?.filter(c => c.id && (c.expiresAt === undefined || c.expiresAt > Date.now()))
+        const credit = usage.resetCredits
+            ?.filter((c) => c.id && (c.expiresAt === undefined || c.expiresAt > Date.now()))
             .sort((a, b) => (a.expiresAt ?? Infinity) - (b.expiresAt ?? Infinity))[0];
         if (!credit?.id)
             throw new Error('No available reset credit.');
@@ -64,7 +68,14 @@ export class ResetRedemption {
         const ticket = randomUUID();
         const expiresAt = Date.now() + 60_000;
         this.tickets.set(ticket, { account: who, creditId: credit.id, expiresAt });
-        return { ticket, expiresAt, weeklyUsedPercent, ...(credit.expiresAt === undefined ? {} : { creditExpiresAt: credit.expiresAt }) };
+        return {
+            ticket,
+            expiresAt,
+            weeklyUsedPercent,
+            ...(credit.expiresAt === undefined
+                ? {}
+                : { creditExpiresAt: credit.expiresAt }),
+        };
     }
     async redeem(account, ticket, signal) {
         const who = await this.canonical(account, signal);
@@ -82,7 +93,8 @@ export class ResetRedemption {
             if (pending.expiresAt <= Date.now())
                 throw new Error('Confirmation expired. Start again.');
             this.eligible(usage);
-            if (!usage.resetCredits?.some(c => c.id === pending.creditId && (c.expiresAt === undefined || c.expiresAt > Date.now())))
+            if (!usage.resetCredits?.some((c) => c.id === pending.creditId &&
+                (c.expiresAt === undefined || c.expiresAt > Date.now())))
                 throw new Error('The selected reset is no longer available.');
             // Mark before submission: no blind retry after transport or response ambiguity.
             this.uncertain.add(who);