dsh-subscriptions 0.2.0 → 0.2.2

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);