@jsonstudio/llms 0.6.1449 → 0.6.1643

package/dist/quota/types.d.ts

@@ -0,0 +1,61 @@
+export type QuotaReason = 'ok' | 'cooldown' | 'blacklist' | 'quotaDepleted' | 'fatal' | 'authVerify';
+export type QuotaAuthType = 'apikey' | 'oauth' | 'unknown';
+export type QuotaAuthIssue = {
+    kind: 'google_account_verification';
+    url?: string | null;
+    message?: string | null;
+} | null;
+export interface StaticQuotaConfig {
+    priorityTier?: number | null;
+    authType?: QuotaAuthType | null;
+    /**
+     * Daily reset time for apikey quota exhaustion (HTTP 402).
+     * Format:
+     * - "HH:mm" => local time
+     * - "HH:mmZ" => UTC time
+     * If not set, defaults to 12:00 local.
+     */
+    apikeyDailyResetTime?: string | null;
+}
+export type ErrorSeries = 'E429' | 'E5XX' | 'ENET' | 'EFATAL' | 'EOTHER';
+export interface QuotaState {
+    providerKey: string;
+    inPool: boolean;
+    reason: QuotaReason;
+    authType: QuotaAuthType;
+    authIssue?: QuotaAuthIssue;
+    priorityTier: number;
+    cooldownUntil: number | null;
+    blacklistUntil: number | null;
+    lastErrorSeries: ErrorSeries | null;
+    lastErrorCode: string | null;
+    lastErrorAtMs: number | null;
+    consecutiveErrorCount: number;
+}
+export interface ErrorEventForQuota {
+    providerKey: string;
+    code?: string | null;
+    httpStatus?: number | null;
+    fatal?: boolean | null;
+    timestampMs?: number;
+    /**
+     * Optional upstream resetAt ISO string for HTTP 402 quota depletion.
+     */
+    resetAt?: string | null;
+    /**
+     * Optional auth issue hint extracted by host/core adapters.
+     */
+    authIssue?: QuotaAuthIssue;
+}
+export interface SuccessEventForQuota {
+    providerKey: string;
+    timestampMs?: number;
+}
+export type QuotaStoreSnapshot = {
+    savedAtMs: number;
+    providers: Record<string, QuotaState>;
+};
+export interface QuotaStore {
+    load(): Promise<QuotaStoreSnapshot | null>;
+    save(snapshot: QuotaStoreSnapshot): Promise<void>;
+}

package/dist/quota/types.js

@@ -0,0 +1 @@
+export {};

package/dist/router/virtual-router/bootstrap.js

@@ -13,6 +13,19 @@ const DEFAULT_CONTEXT_ROUTING = {
     warnRatio: 0.9,
     hardLimit: false
 };
+const CLAUDE_CODE_DEFAULT_USER_AGENT = 'claude-cli/2.0.76 (external, cli)';
+const CLAUDE_CODE_DEFAULT_X_APP = 'claude-cli';
+// Claude Code upstream gates may require anthropic-beta to be present (value is service-specific).
+const CLAUDE_CODE_DEFAULT_ANTHROPIC_BETA = 'claude-code';
+function parseClaudeCodeAppVersionFromUserAgent(userAgent) {
+    const ua = typeof userAgent === 'string' ? userAgent.trim() : '';
+    if (!ua) {
+        return null;
+    }
+    const match = /claude-cli\/([0-9][^ )]*)/i.exec(ua);
+    const version = match?.[1]?.trim() ?? '';
+    return version ? version : null;
+}
 /**
  * 将用户提供的 Virtual Router 配置（或包含 virtualrouter 字段的整体配置）
  * 规范化为 VirtualRouterConfig，供 HubPipeline / VirtualRouterEngine 直接使用。
@@ -32,7 +45,7 @@ export function bootstrapVirtualRouterConfig(input) {
     const execCommandGuard = normalizeExecCommandGuard(section.execCommandGuard);
     const clock = normalizeClock(section.clock);
     const { runtimeEntries, aliasIndex, modelIndex } = buildProviderRuntimeEntries(providersSource);
-    const { routing, targetKeys } = expandRoutingTable(routingSource, aliasIndex);
+    const { routing, targetKeys } = expandRoutingTable(routingSource, aliasIndex, modelIndex);
     if (!routing.default || routing.default.length === 0) {
         throw new VirtualRouterError('Virtual Router default route must contain at least one provider target', VirtualRouterErrorCode.CONFIG_ERROR);
     }
@@ -42,7 +55,7 @@ export function bootstrapVirtualRouterConfig(input) {
     // so that "direct model" and "prefer model" routing can bypass route pools when needed.
     const expandedTargetKeys = new Set(targetKeys);
     for (const [providerId, aliases] of aliasIndex.entries()) {
-        const models = modelIndex.get(providerId) ?? [];
+        const models = modelIndex.get(providerId)?.models ?? [];
         if (!models.length || !aliases.length) {
             continue;
         }
@@ -116,6 +129,14 @@ function normalizeClock(raw) {
     if (typeof record.tickMs === 'number' && Number.isFinite(record.tickMs) && record.tickMs >= 0) {
         out.tickMs = Math.floor(record.tickMs);
     }
+    if (record.holdNonStreaming === true ||
+        (typeof record.holdNonStreaming === 'string' && record.holdNonStreaming.trim().toLowerCase() === 'true') ||
+        (typeof record.holdNonStreaming === 'number' && record.holdNonStreaming === 1)) {
+        out.holdNonStreaming = true;
+    }
+    if (typeof record.holdMaxMs === 'number' && Number.isFinite(record.holdMaxMs) && record.holdMaxMs >= 0) {
+        out.holdMaxMs = Math.floor(record.holdMaxMs);
+    }
     return out;
 }
 function buildProviderRuntimeEntries(providers) {
@@ -124,8 +145,10 @@ function buildProviderRuntimeEntries(providers) {
     const modelIndex = new Map();
     for (const [providerId, providerRaw] of Object.entries(providers)) {
         const normalizedProvider = normalizeProvider(providerId, providerRaw);
-        const modelsNode = asRecord(providerRaw?.models);
-        modelIndex.set(providerId, modelsNode ? Object.keys(modelsNode).filter(Boolean) : []);
+        const rawModelsNode = providerRaw?.models;
+        const modelsDeclared = rawModelsNode !== undefined;
+        const modelsNode = asRecord(rawModelsNode);
+        modelIndex.set(providerId, { declared: modelsDeclared, models: Object.keys(modelsNode).filter(Boolean) });
         const authEntries = extractProviderAuthEntries(providerId, providerRaw);
         if (!authEntries.length) {
             throw new VirtualRouterError(`Provider ${providerId} requires at least one auth entry`, VirtualRouterErrorCode.CONFIG_ERROR);
@@ -179,7 +202,7 @@ function buildProviderRuntimeEntries(providers) {
     }
     return { runtimeEntries, aliasIndex, modelIndex };
 }
-function expandRoutingTable(routingSource, aliasIndex) {
+function expandRoutingTable(routingSource, aliasIndex, modelIndex) {
     const routing = {};
     const targetKeys = new Set();
     for (const [routeName, pools] of Object.entries(routingSource)) {
@@ -195,6 +218,19 @@ function expandRoutingTable(routingSource, aliasIndex) {
                 if (!aliasIndex.has(parsed.providerId)) {
                     throw new VirtualRouterError(`Route "${routeName}" references unknown provider "${parsed.providerId}"`, VirtualRouterErrorCode.CONFIG_ERROR);
                 }
+                const modelInfo = modelIndex.get(parsed.providerId);
+                if (modelInfo?.declared) {
+                    if (!parsed.modelId) {
+                        throw new VirtualRouterError(`Route "${routeName}" references empty model id for provider "${parsed.providerId}"`, VirtualRouterErrorCode.CONFIG_ERROR);
+                    }
+                    const knownModels = modelInfo.models ?? [];
+                    if (!knownModels.length) {
+                        throw new VirtualRouterError(`Route "${routeName}" references provider "${parsed.providerId}" but provider declares no models`, VirtualRouterErrorCode.CONFIG_ERROR);
+                    }
+                    if (!knownModels.includes(parsed.modelId)) {
+                        throw new VirtualRouterError(`Route "${routeName}" references unknown model "${parsed.modelId}" for provider "${parsed.providerId}"`, VirtualRouterErrorCode.CONFIG_ERROR);
+                    }
+                }
                 const aliases = parsed.keyAlias ? [parsed.keyAlias] : aliasIndex.get(parsed.providerId);
                 if (!aliases.length) {
                     throw new VirtualRouterError(`Provider ${parsed.providerId} has no auth aliases but is referenced in routing`, VirtualRouterErrorCode.CONFIG_ERROR);
@@ -476,8 +512,8 @@ function normalizeProvider(providerId, raw) {
             : typeof provider.baseUrl === 'string' && provider.baseUrl.trim()
                 ? provider.baseUrl.trim()
                 : '';
-    const headers = normalizeHeaders(provider.headers);
     const compatibilityProfile = resolveCompatibilityProfile(providerId, provider);
+    const headers = maybeInjectClaudeCodeHeaders(providerId, providerType, compatibilityProfile, normalizeHeaders(provider.headers));
     const responsesNode = asRecord(provider.responses);
     const responsesConfig = normalizeResponsesConfig(provider, responsesNode);
     const processMode = normalizeProcessMode(provider.process);
@@ -506,6 +542,50 @@ function normalizeProvider(providerId, raw) {
         ...(serverToolsDisabled ? { serverToolsDisabled: true } : {})
     };
 }
+function hasHeader(headers, name) {
+    if (!headers) {
+        return false;
+    }
+    const lowered = name.trim().toLowerCase();
+    if (!lowered) {
+        return false;
+    }
+    for (const key of Object.keys(headers)) {
+        if (key.trim().toLowerCase() === lowered) {
+            const value = headers[key];
+            if (typeof value === 'string' && value.trim()) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function maybeInjectClaudeCodeHeaders(_providerId, providerType, compatibilityProfile, headers) {
+    const profile = typeof compatibilityProfile === 'string' ? compatibilityProfile.trim().toLowerCase() : '';
+    if (!profile || (profile !== 'anthropic:claude-code' && profile !== 'chat:claude-code')) {
+        return headers;
+    }
+    if (!String(providerType).toLowerCase().includes('anthropic')) {
+        return headers;
+    }
+    const base = { ...(headers ?? {}) };
+    if (!hasHeader(base, 'User-Agent')) {
+        base['User-Agent'] = CLAUDE_CODE_DEFAULT_USER_AGENT;
+    }
+    if (!hasHeader(base, 'X-App')) {
+        base['X-App'] = CLAUDE_CODE_DEFAULT_X_APP;
+    }
+    if (!hasHeader(base, 'X-App-Version')) {
+        const version = parseClaudeCodeAppVersionFromUserAgent(base['User-Agent'] ?? '');
+        if (version) {
+            base['X-App-Version'] = version;
+        }
+    }
+    if (!hasHeader(base, 'anthropic-beta')) {
+        base['anthropic-beta'] = CLAUDE_CODE_DEFAULT_ANTHROPIC_BETA;
+    }
+    return base;
+}
 function normalizeModelStreaming(provider) {
     const modelsNode = asRecord(provider.models);
     if (!modelsNode) {
@@ -1221,6 +1301,21 @@ function normalizeAliasSelection(raw) {
     const record = raw;
     const enabled = typeof record.enabled === 'boolean' ? record.enabled : undefined;
     const defaultStrategy = coerceAliasSelectionStrategy(record.defaultStrategy);
+    const sessionLeaseCooldownMs = typeof record.sessionLeaseCooldownMs === 'number' && Number.isFinite(record.sessionLeaseCooldownMs)
+        ? Math.max(0, Math.floor(record.sessionLeaseCooldownMs))
+        : typeof record.sessionLease_cooldown_ms === 'number' && Number.isFinite(record.sessionLease_cooldown_ms)
+            ? Math.max(0, Math.floor(record.sessionLease_cooldown_ms))
+            : undefined;
+    const antigravitySessionBindingRaw = typeof record.antigravitySessionBinding === 'string'
+        ? record.antigravitySessionBinding.trim().toLowerCase()
+        : typeof record.antigravity_session_binding === 'string'
+            ? String(record.antigravity_session_binding).trim().toLowerCase()
+            : '';
+    const antigravitySessionBinding = antigravitySessionBindingRaw === 'strict'
+        ? 'strict'
+        : antigravitySessionBindingRaw === 'lease'
+            ? 'lease'
+            : undefined;
     const providersRaw = asRecord(record.providers);
     const providers = {};
     for (const [providerId, value] of Object.entries(providersRaw)) {
@@ -1232,6 +1327,8 @@ function normalizeAliasSelection(raw) {
     const out = {
         ...(enabled !== undefined ? { enabled } : {}),
         ...(defaultStrategy ? { defaultStrategy } : {}),
+        ...(sessionLeaseCooldownMs !== undefined ? { sessionLeaseCooldownMs } : {}),
+        ...(antigravitySessionBinding ? { antigravitySessionBinding } : {}),
         ...(Object.keys(providers).length ? { providers } : {})
     };
     return Object.keys(out).length ? out : undefined;

package/dist/router/virtual-router/engine-health.js

@@ -105,6 +105,7 @@ const ANTIGRAVITY_RISK_RESET_WINDOW_MS = readEnvDuration('ROUTECODEX_ANTIGRAVITY
 const ANTIGRAVITY_RISK_COOLDOWN_MS = readEnvDuration('ROUTECODEX_ANTIGRAVITY_RISK_COOLDOWN', 5 * 60_000);
 const ANTIGRAVITY_RISK_BAN_MS = readEnvDuration('ROUTECODEX_ANTIGRAVITY_RISK_BAN', 24 * 60 * 60_000);
 const ANTIGRAVITY_AUTH_VERIFY_BAN_MS = readEnvDuration('ROUTECODEX_ANTIGRAVITY_AUTH_VERIFY_BAN', 24 * 60 * 60_000);
+const ANTIGRAVITY_THOUGHT_SIGNATURE_MISSING_COOLDOWN_MS = readEnvDuration('ROUTECODEX_ANTIGRAVITY_THOUGHT_SIGNATURE_MISSING_COOLDOWN', 5 * 60_000);
 function isAntigravityEvent(event) {
     const runtime = event?.runtime;
     if (!runtime || typeof runtime !== 'object') {
@@ -145,6 +146,11 @@ function isGoogleAccountVerificationRequired(event) {
     }
     const lowered = sources.join(' | ').toLowerCase();
     return (lowered.includes('verify your account') ||
+        // Antigravity-Manager alignment: 403 validation gating keywords.
+        lowered.includes('validation_required') ||
+        lowered.includes('validation required') ||
+        lowered.includes('validation_url') ||
+        lowered.includes('validation url') ||
         lowered.includes('accounts.google.com/signin/continue') ||
         lowered.includes('support.google.com/accounts?p=al_alert'));
 }
@@ -187,6 +193,68 @@ function computeAntigravityRiskSignature(event) {
     const parts = [status, code, stage].filter((p) => p.length > 0);
     return parts.length ? parts.join(':') : 'unknown';
 }
+function isAntigravityThoughtSignatureMissing(event) {
+    const code = typeof event.code === 'string' ? event.code.trim().toLowerCase() : '';
+    if (code.includes('thought') && code.includes('signature')) {
+        return true;
+    }
+    const sources = [];
+    const message = typeof event.message === 'string' ? event.message : '';
+    if (message)
+        sources.push(message);
+    const details = event.details;
+    if (details && typeof details === 'object' && !Array.isArray(details)) {
+        const upstreamMessage = details.upstreamMessage;
+        if (typeof upstreamMessage === 'string' && upstreamMessage.trim()) {
+            sources.push(upstreamMessage);
+        }
+        const meta = details.meta;
+        if (meta && typeof meta === 'object' && !Array.isArray(meta)) {
+            const metaUpstream = meta.upstreamMessage;
+            if (typeof metaUpstream === 'string' && metaUpstream.trim()) {
+                sources.push(metaUpstream);
+            }
+            const metaMessage = meta.message;
+            if (typeof metaMessage === 'string' && metaMessage.trim()) {
+                sources.push(metaMessage);
+            }
+        }
+    }
+    if (sources.length === 0) {
+        return false;
+    }
+    for (const source of sources) {
+        const lowered = source.toLowerCase();
+        // Match both "thoughtSignature" and "thought signature" variants, as well as "reasoning signature".
+        const mentionsSignature = lowered.includes('thoughtsignature') ||
+            lowered.includes('thought signature') ||
+            lowered.includes('reasoning_signature') ||
+            lowered.includes('reasoning signature');
+        if (!mentionsSignature) {
+            continue;
+        }
+        // Match common failure patterns in upstream error messages.
+        if (lowered.includes('missing') ||
+            lowered.includes('required') ||
+            lowered.includes('invalid') ||
+            lowered.includes('not provided') ||
+            lowered.includes('签名') ||
+            lowered.includes('缺少') ||
+            lowered.includes('无效')) {
+            return true;
+        }
+    }
+    return false;
+}
+function shouldApplyGeminiSeriesSignatureFreeze(event) {
+    const status = typeof event.status === 'number' ? event.status : undefined;
+    // Signature missing is a request-shape contract failure; treat as 4xx.
+    if (status !== undefined && status >= 400 && status < 500) {
+        return true;
+    }
+    const code = typeof event.code === 'string' ? event.code.trim().toUpperCase() : '';
+    return /^HTTP_4\d\d$/.test(code) || code.includes('INVALID_ARGUMENT') || code.includes('FAILED_PRECONDITION');
+}
 export function applyAntigravityRiskPolicyImpl(event, providerRegistry, healthManager, markProviderCooldown, debug) {
     if (!event) {
         return;
@@ -228,6 +296,42 @@ export function applyAntigravityRiskPolicyImpl(event, providerRegistry, healthMa
         });
         return;
     }
+    // Thought signature missing is a deterministic incompatibility for Gemini-family flows that require it.
+    // If we keep routing into Antigravity Gemini models without a signature, we create a request storm.
+    // Freeze the *Gemini* series (pro/flash) immediately so the router falls back to non-Antigravity providers.
+    if (isAntigravityThoughtSignatureMissing(event) && shouldApplyGeminiSeriesSignatureFreeze(event)) {
+        const allProviderKeys = providerRegistry.listProviderKeys('antigravity');
+        const providerKeys = runtimeKey
+            ? allProviderKeys.filter((key) => typeof key === 'string' && key.startsWith(`${runtimeKey}.`))
+            : allProviderKeys;
+        const affected = [];
+        for (const key of providerKeys) {
+            try {
+                if (!healthManager.isAvailable(key)) {
+                    continue;
+                }
+                const profile = providerRegistry.get(key);
+                const modelSeries = resolveModelSeries(profile.modelId);
+                if (modelSeries !== 'gemini-pro' && modelSeries !== 'gemini-flash') {
+                    continue;
+                }
+                healthManager.tripProvider(key, 'signature_missing', ANTIGRAVITY_THOUGHT_SIGNATURE_MISSING_COOLDOWN_MS);
+                markProviderCooldown(key, ANTIGRAVITY_THOUGHT_SIGNATURE_MISSING_COOLDOWN_MS);
+                affected.push(key);
+            }
+            catch {
+                // ignore lookup failures
+            }
+        }
+        if (affected.length) {
+            debug?.log?.('[virtual-router] antigravity thoughtSignature missing: freeze gemini series', {
+                ...(runtimeKey ? { runtimeKey } : {}),
+                cooldownMs: ANTIGRAVITY_THOUGHT_SIGNATURE_MISSING_COOLDOWN_MS,
+                affected
+            });
+        }
+        return;
+    }
     const signature = computeAntigravityRiskSignature(event);
     if (!signature || signature === 'unknown') {
         return;

package/dist/router/virtual-router/engine-selection/selection-deps.d.ts

@@ -13,6 +13,24 @@ export type SelectionDeps = {
     resolveStickyKey: (metadata: RouterMetadataInput) => string | undefined;
     quotaView?: ProviderQuotaView;
     aliasQueueStore?: Map<string, string[]>;
+    /**
+     * Antigravity alias session lease (session isolation) store.
+     * Key: runtimeKey (providerId.keyAlias), e.g. "antigravity.aliasA".
+     */
+    antigravityAliasLeaseStore?: Map<string, {
+        sessionKey: string;
+        lastSeenAt: number;
+    }>;
+    /**
+     * Session → runtimeKey mapping for Antigravity alias leases.
+     * Key: session scope key, e.g. "session:abc" / "conversation:xyz".
+     * Value: runtimeKey (providerId.keyAlias)
+     */
+    antigravitySessionAliasStore?: Map<string, string>;
+    /**
+     * Cooldown window (ms) before an Antigravity alias can be reused by a different session.
+     */
+    antigravityAliasReuseCooldownMs?: number;
 };
 export type TrySelectFromTierOptions = {
     disabledProviders?: Set<string>;

package/dist/router/virtual-router/engine-selection/tier-priority.d.ts

@@ -1,10 +1,9 @@
-import type { ProviderHealthManager } from '../health-manager.js';
 import type { ProviderRegistry } from '../provider-registry.js';
 export declare function pickPriorityGroup(opts: {
     candidates: string[];
     orderedTargets: string[];
     providerRegistry: ProviderRegistry;
-    healthManager: ProviderHealthManager;
+    availabilityCheck: (key: string) => boolean;
     penalties?: Record<string, number>;
 }): {
     groupId: string;

package/dist/router/virtual-router/engine-selection/tier-priority.js

@@ -31,12 +31,12 @@ function resolvePriorityMeta(orderedTargets, providerRegistry) {
     return meta;
 }
 export function pickPriorityGroup(opts) {
-    const { candidates, orderedTargets, providerRegistry, healthManager, penalties } = opts;
+    const { candidates, orderedTargets, providerRegistry, availabilityCheck, penalties } = opts;
     const meta = resolvePriorityMeta(orderedTargets, providerRegistry);
     let bestGroupId = null;
     let bestScore = Number.NEGATIVE_INFINITY;
     for (const key of candidates) {
-        if (!healthManager.isAvailable(key))
+        if (!availabilityCheck(key))
             continue;
         const m = meta.get(key);
         if (!m)

package/dist/router/virtual-router/engine-selection/tier-selection-select.js

@@ -67,7 +67,7 @@ function applyAliasStickyQueuePinning(opts) {
             excludedProviderKeys: excludedKeys,
             aliasOfKey: extractKeyAlias,
             modelIdOfKey: (key) => getProviderModelId(key, deps.providerRegistry),
-            availabilityCheck: (key) => deps.healthManager.isAvailable(key)
+            availabilityCheck: (key) => deps.healthManager.isAvailable(key) || Boolean(deps.quotaView?.(key))
         });
         if (pinned && pinned.length) {
             pinnedByGroup.set(groupId, new Set(pinned));
@@ -137,9 +137,33 @@ function preferAntigravityAliasesOnRetry(opts) {
 export function selectProviderKeyFromCandidatePool(opts) {
     const { routeName, tier, stickyKey, candidates, isSafePool, deps, options, contextResult, warnRatio, excludedKeys, isRecoveryAttempt, now, nowForWeights, healthWeightedCfg, contextWeightedCfg } = opts;
     const quotaView = deps.quotaView;
+    const isAvailable = (key) => {
+        if (!quotaView) {
+            return deps.healthManager.isAvailable(key);
+        }
+        const entry = quotaView(key);
+        if (!entry) {
+            // When quotaView is present, quota is the source of truth for availability.
+            // Treat unknown entries as "in pool" so routing does not depend on router-local health.
+            return true;
+        }
+        if (entry.inPool === false) {
+            return false;
+        }
+        if (entry.cooldownUntil && entry.cooldownUntil > now) {
+            return false;
+        }
+        if (entry.blacklistUntil && entry.blacklistUntil > now) {
+            return false;
+        }
+        // When quotaView is injected, quota is the source of truth for availability.
+        // Do not let router-local health snapshots (which may be stale or intentionally disabled)
+        // prevent selection for in-pool targets.
+        return true;
+    };
     const selectFirstAvailable = (keys) => {
         for (const key of keys) {
-            if (deps.healthManager.isAvailable(key)) {
+            if (isAvailable(key)) {
                 return key;
             }
         }
@@ -171,7 +195,7 @@ export function selectProviderKeyFromCandidatePool(opts) {
                 candidates: pinnedCandidates,
                 orderedTargets: tier.targets,
                 providerRegistry: deps.providerRegistry,
-                healthManager: deps.healthManager
+                availabilityCheck: isAvailable
             });
             if (!group) {
                 return null;
@@ -198,7 +222,7 @@ export function selectProviderKeyFromCandidatePool(opts) {
                 candidates: group.groupCandidates,
                 stickyKey: options.allowAliasRotation ? undefined : stickyKey,
                 weights,
-                availabilityCheck: (key) => deps.healthManager.isAvailable(key)
+                availabilityCheck: isAvailable
             }, 'round-robin');
         }
         const weights = (() => {
@@ -223,7 +247,7 @@ export function selectProviderKeyFromCandidatePool(opts) {
             candidates: pinnedCandidates,
             stickyKey: options.allowAliasRotation ? undefined : stickyKey,
             weights,
-            availabilityCheck: (key) => deps.healthManager.isAvailable(key)
+            availabilityCheck: isAvailable
         }, tier.mode === 'round-robin' ? 'round-robin' : undefined);
     }
     const buckets = new Map();
@@ -313,7 +337,7 @@ export function selectProviderKeyFromCandidatePool(opts) {
                     candidates: bucketCandidates,
                     orderedTargets: tier.targets,
                     providerRegistry: deps.providerRegistry,
-                    healthManager: deps.healthManager,
+                    availabilityCheck: isAvailable,
                     penalties: bucketPenaltyMap
                 });
                 if (!group) {
@@ -328,7 +352,7 @@ export function selectProviderKeyFromCandidatePool(opts) {
                     candidates: group.groupCandidates,
                     stickyKey: options.allowAliasRotation ? undefined : stickyKey,
                     weights: groupWeights,
-                    availabilityCheck: (key) => deps.healthManager.isAvailable(key)
+                    availabilityCheck: isAvailable
                 }, 'round-robin');
                 if (selected) {
                     return selected;
@@ -339,7 +363,7 @@ export function selectProviderKeyFromCandidatePool(opts) {
                 let best = null;
                 let bestM = Number.NEGATIVE_INFINITY;
                 for (const key of bucketCandidates) {
-                    if (!deps.healthManager.isAvailable(key))
+                    if (!isAvailable(key))
                         continue;
                     const m = bucketMultipliers[key] ?? 1;
                     if (m > bestM) {
@@ -365,7 +389,7 @@ export function selectProviderKeyFromCandidatePool(opts) {
                 let best = null;
                 let bestM = Number.NEGATIVE_INFINITY;
                 for (const key of bucketCandidates) {
-                    if (!deps.healthManager.isAvailable(key))
+                    if (!isAvailable(key))
                         continue;
                     const m = bucketMultipliers[key] ?? 1;
                     if (m > bestM) {
@@ -389,7 +413,7 @@ export function selectProviderKeyFromCandidatePool(opts) {
                 candidates: bucketCandidates,
                 stickyKey: options.allowAliasRotation ? undefined : stickyKey,
                 weights: bucketWeights,
-                availabilityCheck: (key) => deps.healthManager.isAvailable(key)
+                availabilityCheck: isAvailable
             }, tier.mode === 'round-robin' ? 'round-robin' : undefined);
             if (selected) {
                 return selected;