@jsonstudio/rcc 0.90.323 → 0.90.364

package/vendor/@jsonstudio/llms/dist/router/virtual-router/engine-selection/tier-selection-select.js

@@ -0,0 +1,352 @@
+import { computeContextMultiplier } from '../context-weighted.js';
+import { pinCandidatesByAliasQueue, resolveAliasSelectionStrategy } from './alias-selection.js';
+import { computeContextWeightMultipliers } from './context-weight-multipliers.js';
+import { extractKeyAlias, extractProviderId, getProviderModelId } from './key-parsing.js';
+import { buildCandidateWeights, buildGroupWeights, hasNonUniformWeights, resolveTierLoadBalancing } from './tier-load-balancing.js';
+import { pickPriorityGroup } from './tier-priority.js';
+import { selectProviderKeyWithQuotaBuckets } from './tier-selection-quota-integration.js';
+function buildPrimaryTargetGroups(candidates, deps) {
+    const groups = new Map();
+    for (const key of candidates) {
+        const providerId = extractProviderId(key) ?? '';
+        if (!providerId) {
+            continue;
+        }
+        let modelId;
+        try {
+            modelId = getProviderModelId(key, deps.providerRegistry) ?? undefined;
+        }
+        catch {
+            modelId = undefined;
+        }
+        const groupId = modelId ? `${providerId}.${modelId}` : providerId;
+        const entry = groups.get(groupId) ?? [];
+        entry.push(key);
+        groups.set(groupId, entry);
+    }
+    return groups;
+}
+function applyAliasStickyQueuePinning(opts) {
+    const { candidates, orderedTargets, deps, excludedKeys } = opts;
+    if (!Array.isArray(candidates) || candidates.length < 2) {
+        return candidates;
+    }
+    const store = deps.aliasQueueStore;
+    if (!store) {
+        return candidates;
+    }
+    // Candidates may include multiple providers. Apply sticky-queue pinning per (providerId, modelId) group
+    // while preserving cross-provider competition.
+    const groups = new Map();
+    const keyToGroup = new Map();
+    for (const key of candidates) {
+        if (!key || typeof key !== 'string') {
+            continue;
+        }
+        const providerId = extractProviderId(key) ?? '';
+        if (!providerId) {
+            continue;
+        }
+        const strategy = resolveAliasSelectionStrategy(providerId, deps.loadBalancer.getPolicy().aliasSelection);
+        if (strategy !== 'sticky-queue') {
+            continue;
+        }
+        const modelId = getProviderModelId(key, deps.providerRegistry) ?? '';
+        if (!modelId) {
+            continue;
+        }
+        const groupId = `${providerId}::${modelId}`;
+        const entry = groups.get(groupId) ?? { providerId, modelId, keys: [] };
+        entry.keys.push(key);
+        groups.set(groupId, entry);
+        keyToGroup.set(key, groupId);
+    }
+    if (groups.size === 0) {
+        return candidates;
+    }
+    const pinnedByGroup = new Map();
+    for (const [groupId, group] of groups.entries()) {
+        if (group.keys.length < 2) {
+            continue;
+        }
+        // Only pin when we have multiple aliases for the same provider+model.
+        const aliases = new Set();
+        for (const key of group.keys) {
+            const alias = extractKeyAlias(key);
+            if (alias) {
+                aliases.add(alias);
+            }
+        }
+        if (aliases.size < 2) {
+            continue;
+        }
+        const pinned = pinCandidatesByAliasQueue({
+            queueStore: store,
+            providerId: group.providerId,
+            modelId: group.modelId,
+            candidates: group.keys,
+            orderedTargets,
+            excludedProviderKeys: excludedKeys,
+            aliasOfKey: extractKeyAlias,
+            modelIdOfKey: (key) => getProviderModelId(key, deps.providerRegistry),
+            availabilityCheck: (key) => deps.healthManager.isAvailable(key) || Boolean(deps.quotaView?.(key))
+        });
+        if (pinned && pinned.length) {
+            pinnedByGroup.set(groupId, new Set(pinned));
+        }
+    }
+    if (pinnedByGroup.size === 0) {
+        return candidates;
+    }
+    return candidates.filter((key) => {
+        const groupId = keyToGroup.get(key);
+        if (!groupId) {
+            return true;
+        }
+        const pinned = pinnedByGroup.get(groupId);
+        return pinned ? pinned.has(key) : true;
+    });
+}
+function preferAntigravityAliasesOnRetry(opts) {
+    const { candidates, excludedKeys, deps } = opts;
+    if (!Array.isArray(candidates) || candidates.length < 2) {
+        return candidates;
+    }
+    if (!excludedKeys || excludedKeys.size === 0) {
+        return candidates;
+    }
+    // Only apply this stronger retry preference for Antigravity.
+    const strategy = resolveAliasSelectionStrategy('antigravity', deps.loadBalancer.getPolicy().aliasSelection);
+    if (strategy !== 'sticky-queue') {
+        return candidates;
+    }
+    const excludedModels = new Set();
+    for (const ex of excludedKeys) {
+        if (!ex || typeof ex !== 'string')
+            continue;
+        if ((extractProviderId(ex) ?? '') !== 'antigravity')
+            continue;
+        try {
+            const modelId = getProviderModelId(ex, deps.providerRegistry) ?? '';
+            if (modelId) {
+                excludedModels.add(modelId);
+            }
+        }
+        catch {
+            // ignore unknown model ids
+        }
+    }
+    if (excludedModels.size === 0) {
+        return candidates;
+    }
+    const preferred = candidates.filter((key) => {
+        if (!key || typeof key !== 'string')
+            return false;
+        if ((extractProviderId(key) ?? '') !== 'antigravity')
+            return false;
+        try {
+            const modelId = getProviderModelId(key, deps.providerRegistry) ?? '';
+            return modelId && excludedModels.has(modelId);
+        }
+        catch {
+            return false;
+        }
+    });
+    // If we still have any Antigravity candidates for the failing model, keep retrying within Antigravity
+    // (rotate aliases) before falling back to other pool targets.
+    return preferred.length > 0 ? preferred : candidates;
+}
+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 tierLoadBalancing = resolveTierLoadBalancing(tier, deps.loadBalancer.getPolicy());
+    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 (isAvailable(key)) {
+                return key;
+            }
+        }
+        return null;
+    };
+    if (!quotaView) {
+        // Single-provider pool should never be "emptied" by health/cooldown.
+        // If there's only one possible target, we must return it even if it's currently unhealthy,
+        // otherwise context routing can incorrectly fall back to a smaller-context route.
+        if (candidates.length === 1) {
+            return candidates[0] ?? null;
+        }
+        const retryPreferredCandidates = isRecoveryAttempt
+            ? preferAntigravityAliasesOnRetry({ candidates, excludedKeys, deps })
+            : candidates;
+        // Alias-level selection strategy (config-driven).
+        // Apply sticky-queue pinning per provider/model group (candidates can be mixed providers).
+        const pinnedCandidates = applyAliasStickyQueuePinning({
+            candidates: retryPreferredCandidates,
+            orderedTargets: tier.targets,
+            deps,
+            excludedKeys
+        });
+        if (tier.mode === 'priority') {
+            if (isRecoveryAttempt) {
+                return selectFirstAvailable(pinnedCandidates);
+            }
+            const group = pickPriorityGroup({
+                candidates: pinnedCandidates,
+                orderedTargets: tier.targets,
+                providerRegistry: deps.providerRegistry,
+                availabilityCheck: isAvailable
+            });
+            if (!group) {
+                return null;
+            }
+            const weights = buildCandidateWeights({
+                candidates: group.groupCandidates,
+                providerRegistry: deps.providerRegistry,
+                staticWeights: tierLoadBalancing.weights,
+                dynamicWeights: (() => {
+                    if (!isSafePool)
+                        return undefined;
+                    const ctx = computeContextWeightMultipliers({ candidates: group.groupCandidates, usage: contextResult.usage, warnRatio, cfg: contextWeightedCfg });
+                    if (!ctx)
+                        return undefined;
+                    const out = {};
+                    for (const key of group.groupCandidates) {
+                        const m = computeContextMultiplier({
+                            effectiveSafeRefTokens: ctx.ref,
+                            effectiveSafeTokens: ctx.eff[key] ?? 1,
+                            cfg: contextWeightedCfg
+                        });
+                        out[key] = Math.max(1, Math.round(100 * m));
+                    }
+                    return out;
+                })()
+            });
+            const allowGrouped = !hasNonUniformWeights(group.groupCandidates, weights);
+            if (allowGrouped && tierLoadBalancing.strategy !== 'sticky') {
+                const groups = buildPrimaryTargetGroups(group.groupCandidates, deps);
+                if (groups.size > 0) {
+                    const groupWeights = buildGroupWeights(groups, tierLoadBalancing.weights);
+                    const selected = deps.loadBalancer.selectGrouped({
+                        routeName: `${routeName}:${tier.id}:priority:group:${group.groupId}`,
+                        groups,
+                        stickyKey: options.allowAliasRotation ? undefined : stickyKey,
+                        weights: groupWeights,
+                        availabilityCheck: isAvailable
+                    }, 'round-robin');
+                    if (selected) {
+                        return selected;
+                    }
+                }
+            }
+            return deps.loadBalancer.select({
+                routeName: `${routeName}:${tier.id}:priority:group:${group.groupId}`,
+                candidates: group.groupCandidates,
+                stickyKey: options.allowAliasRotation ? undefined : stickyKey,
+                weights,
+                availabilityCheck: isAvailable
+            }, 'round-robin');
+        }
+        const weights = buildCandidateWeights({
+            candidates: pinnedCandidates,
+            providerRegistry: deps.providerRegistry,
+            staticWeights: tierLoadBalancing.weights,
+            dynamicWeights: (() => {
+                if (!isSafePool || !contextWeightedCfg.enabled)
+                    return undefined;
+                const ctx = computeContextWeightMultipliers({ candidates: pinnedCandidates, usage: contextResult.usage, warnRatio, cfg: contextWeightedCfg });
+                if (!ctx)
+                    return undefined;
+                const out = {};
+                for (const key of pinnedCandidates) {
+                    const m = computeContextMultiplier({
+                        effectiveSafeRefTokens: ctx.ref,
+                        effectiveSafeTokens: ctx.eff[key] ?? 1,
+                        cfg: contextWeightedCfg
+                    });
+                    out[key] = Math.max(1, Math.round(100 * m));
+                }
+                return out;
+            })()
+        });
+        const allowGrouped = !hasNonUniformWeights(pinnedCandidates, weights);
+        if (allowGrouped && tierLoadBalancing.strategy !== 'sticky') {
+            const groups = buildPrimaryTargetGroups(pinnedCandidates, deps);
+            if (groups.size > 0) {
+                const groupWeights = buildGroupWeights(groups, tierLoadBalancing.weights);
+                const selected = deps.loadBalancer.selectGrouped({
+                    routeName: `${routeName}:${tier.id}`,
+                    groups,
+                    stickyKey: options.allowAliasRotation ? undefined : stickyKey,
+                    weights: groupWeights,
+                    availabilityCheck: isAvailable
+                }, tier.mode === 'round-robin' ? 'round-robin' : tierLoadBalancing.strategy);
+                if (selected) {
+                    return selected;
+                }
+            }
+        }
+        return deps.loadBalancer.select({
+            routeName: `${routeName}:${tier.id}`,
+            candidates: pinnedCandidates,
+            stickyKey: options.allowAliasRotation ? undefined : stickyKey,
+            weights,
+            availabilityCheck: isAvailable
+        }, tier.mode === 'round-robin' ? 'round-robin' : tierLoadBalancing.strategy);
+    }
+    return selectProviderKeyWithQuotaBuckets({
+        routeName,
+        tier,
+        stickyKey,
+        candidates,
+        isSafePool,
+        deps,
+        options,
+        contextResult,
+        warnRatio,
+        excludedKeys,
+        isRecoveryAttempt,
+        now,
+        nowForWeights,
+        healthWeightedCfg,
+        contextWeightedCfg,
+        tierLoadBalancing,
+        quotaView,
+        isAvailable,
+        selectFirstAvailable,
+        applyAliasStickyQueuePinning: (quotaCandidates) => applyAliasStickyQueuePinning({
+            candidates: quotaCandidates,
+            orderedTargets: tier.targets,
+            deps,
+            excludedKeys
+        }),
+        preferAntigravityAliasesOnRetry: (quotaCandidates) => preferAntigravityAliasesOnRetry({
+            candidates: quotaCandidates,
+            excludedKeys,
+            deps
+        })
+    });
+}

package/vendor/@jsonstudio/llms/dist/router/virtual-router/engine-selection/tier-selection.d.ts

@@ -0,0 +1,3 @@
+import type { RoutePoolTier, RoutingFeatures } from '../types.js';
+import type { SelectionDeps, TrySelectFromTierOptions, SelectionResult } from './selection-deps.js';
+export declare function trySelectFromTier(routeName: string, tier: RoutePoolTier, stickyKey: string | undefined, estimatedTokens: number, features: RoutingFeatures, deps: SelectionDeps, options: TrySelectFromTierOptions): SelectionResult;

package/vendor/@jsonstudio/llms/dist/router/virtual-router/engine-selection/tier-selection.js

@@ -0,0 +1,309 @@
+import { DEFAULT_ROUTE } from '../types.js';
+import { resolveContextWeightedConfig } from '../context-weighted.js';
+import { resolveHealthWeightedConfig } from '../health-weighted.js';
+import { pinCandidatesByAliasQueue, resolveAliasSelectionStrategy } from './alias-selection.js';
+import { extractKeyAlias, extractKeyIndex, extractProviderId, getProviderModelId } from './key-parsing.js';
+import { providerSupportsMultimodalRequest } from './multimodal-capability.js';
+import { selectProviderKeyFromCandidatePool } from './tier-selection-select.js';
+import { applyAntigravityAliasSessionLeases, extractLeaseRuntimeKey, isAntigravityGeminiModelKey, } from './tier-selection-antigravity-session-lease.js';
+import { extractNonAntigravityTargets, preferNonAntigravityWhenPossible, shouldAvoidAllAntigravityOnRetry, shouldAvoidAntigravityAfterRepeatedError } from './tier-selection-antigravity-target-split.js';
+export function trySelectFromTier(routeName, tier, stickyKey, estimatedTokens, features, deps, options) {
+    const { disabledProviders, disabledKeysMap, allowedProviders, disabledModels, requiredProviderKeys } = options;
+    let targets = Array.isArray(tier.targets) ? tier.targets : [];
+    let preLeaseTargets = null;
+    const excludedRaw = Array.isArray(features.metadata?.excludedProviderKeys)
+        ? features.metadata.excludedProviderKeys
+            .filter((val) => typeof val === 'string')
+            .map((val) => val.trim())
+            .filter((val) => val.length > 0)
+        : [];
+    const excludedKeys = new Set(excludedRaw);
+    if (excludedKeys.size > 0) {
+        recordAliasQueueFailuresFromExcludedKeys(excludedKeys, tier.targets, deps);
+    }
+    if (excludedKeys.size > 0) {
+        targets = targets.filter((key) => !excludedKeys.has(key));
+    }
+    const isRecoveryAttempt = excludedKeys.size > 0;
+    // Antigravity safety: for certain retry signals (e.g. account verification required),
+    // avoid hitting *any* Antigravity alias on retries to prevent cross-account risk cascades.
+    if (isRecoveryAttempt && shouldAvoidAllAntigravityOnRetry(features.metadata)) {
+        targets = targets.filter((key) => (extractProviderId(key) ?? '') !== 'antigravity');
+    }
+    const singleCandidateFallback = targets.length === 1 ? targets[0] : undefined;
+    if (targets.length > 0) {
+        // When quotaView is present, cooldown is expressed via quotaView.{cooldownUntil,blacklistUntil,inPool}.
+        // Do not apply router-local cooldown filters in that mode.
+        if (!deps.quotaView) {
+            // Always respect cooldown signals. If a route/tier is depleted due to cooldown,
+            // routing is expected to fall back to other tiers/routes (e.g. longcontext → default),
+            // rather than repeatedly selecting the cooled-down provider.
+            targets = targets.filter((key) => !deps.isProviderCoolingDown(key));
+        }
+    }
+    if (allowedProviders && allowedProviders.size > 0) {
+        targets = targets.filter((key) => {
+            const providerId = extractProviderId(key);
+            return providerId && allowedProviders.has(providerId);
+        });
+    }
+    if (disabledProviders && disabledProviders.size > 0) {
+        targets = targets.filter((key) => {
+            const providerId = extractProviderId(key);
+            return providerId && !disabledProviders.has(providerId);
+        });
+    }
+    if (disabledKeysMap && disabledKeysMap.size > 0) {
+        targets = targets.filter((key) => {
+            const providerId = extractProviderId(key);
+            if (!providerId)
+                return true;
+            const disabledKeys = disabledKeysMap.get(providerId);
+            if (!disabledKeys || disabledKeys.size === 0)
+                return true;
+            const keyAlias = extractKeyAlias(key);
+            const keyIndex = extractKeyIndex(key);
+            if (keyAlias && disabledKeys.has(keyAlias)) {
+                return false;
+            }
+            if (keyIndex !== undefined && disabledKeys.has(keyIndex + 1)) {
+                return false;
+            }
+            return true;
+        });
+    }
+    if (disabledModels && disabledModels.size > 0) {
+        targets = targets.filter((key) => {
+            const providerId = extractProviderId(key);
+            if (!providerId) {
+                return true;
+            }
+            const disabled = disabledModels.get(providerId);
+            if (!disabled || disabled.size === 0) {
+                return true;
+            }
+            const modelId = getProviderModelId(key, deps.providerRegistry);
+            if (!modelId) {
+                return true;
+            }
+            return !disabled.has(modelId);
+        });
+    }
+    if (requiredProviderKeys && requiredProviderKeys.size > 0) {
+        targets = targets.filter((key) => requiredProviderKeys.has(key));
+    }
+    // Antigravity session isolation:
+    // - One alias (auth key) must not be shared across different sessions within the cooldown window,
+    //   otherwise upstream may respond with 429 due to cross-session contamination.
+    // - If the current session already has a leased alias, pin it when possible.
+    preLeaseTargets = targets;
+    const leaseResult = applyAntigravityAliasSessionLeases(targets, deps, features.metadata);
+    targets = leaseResult.targets;
+    // Default route must not fail purely due to Antigravity alias leasing.
+    // If *all* candidates are blocked by lease, fall back to the pre-lease pool and let upstream decide.
+    if (!targets.length &&
+        routeName === DEFAULT_ROUTE &&
+        preLeaseTargets &&
+        preLeaseTargets.length > 0 &&
+        leaseResult.blocked > 0 &&
+        !leaseResult.pinnedStrict) {
+        targets = preLeaseTargets;
+    }
+    const serverToolRequired = features.metadata?.serverToolRequired === true;
+    if (serverToolRequired) {
+        const filtered = [];
+        for (const key of targets) {
+            try {
+                const profile = deps.providerRegistry.get(key);
+                if (!profile.serverToolsDisabled) {
+                    filtered.push(key);
+                }
+            }
+            catch {
+                // ignore unknown providers when filtering for servertools
+            }
+        }
+        targets = filtered;
+    }
+    if (features.hasImageAttachment && routeName === 'multimodal') {
+        targets = targets.filter((key) => providerSupportsMultimodalRequest(key, features, deps.providerRegistry));
+        const kimiTargets = targets.filter((key) => {
+            const modelId = getProviderModelId(key, deps.providerRegistry) ?? '';
+            return modelId.trim().toLowerCase() === 'kimi-k2.5';
+        });
+        if (kimiTargets.length) {
+            targets = kimiTargets;
+        }
+        else {
+            const prioritized = [];
+            const fallthrough = [];
+            for (const key of targets) {
+                try {
+                    const profile = deps.providerRegistry.get(key);
+                    if (profile.providerType === 'responses') {
+                        prioritized.push(key);
+                    }
+                    else if (profile.providerType === 'gemini') {
+                        prioritized.push(key);
+                    }
+                    else {
+                        fallthrough.push(key);
+                    }
+                }
+                catch {
+                    fallthrough.push(key);
+                }
+            }
+            if (prioritized.length) {
+                targets = prioritized;
+            }
+        }
+    }
+    if (!targets.length) {
+        const leaseHint = leaseResult.blocked > 0
+            ? `${routeName}:${tier.id}:antigravity_alias_session_busy(${leaseResult.blocked})`
+            : `${routeName}:${tier.id}:empty`;
+        return { providerKey: null, poolTargets: [], tierId: tier.id, failureHint: leaseHint };
+    }
+    const contextResult = deps.contextAdvisor.classify(targets, estimatedTokens, (key) => deps.providerRegistry.get(key));
+    let prioritizedPools = buildContextCandidatePools(contextResult);
+    // ContextAdvisor overflow (ratio >= 1) is not always a hard stop: token estimation is approximate.
+    // For the default route, treat overflow as a last-resort candidate pool when hardLimit=false,
+    // to avoid route exhaustion when no other providers are available.
+    const hardLimit = deps.contextAdvisor.getConfig().hardLimit;
+    if (!hardLimit && routeName === DEFAULT_ROUTE && contextResult.overflow.length > 0) {
+        prioritizedPools = [...prioritizedPools, contextResult.overflow];
+    }
+    const avoidAntigravityOnRetry = isRecoveryAttempt && shouldAvoidAntigravityAfterRepeatedError(features.metadata);
+    const nonAntigravityTargets = avoidAntigravityOnRetry ? extractNonAntigravityTargets(targets) : [];
+    const poolsToTry = avoidAntigravityOnRetry && nonAntigravityTargets.length > 0
+        ? [nonAntigravityTargets, ...prioritizedPools]
+        : prioritizedPools;
+    const quotaView = deps.quotaView;
+    const now = quotaView ? Date.now() : 0;
+    const healthWeightedCfg = resolveHealthWeightedConfig(deps.loadBalancer.getPolicy().healthWeighted);
+    const contextWeightedCfg = resolveContextWeightedConfig(deps.loadBalancer.getPolicy().contextWeighted);
+    const warnRatio = deps.contextAdvisor.getConfig().warnRatio;
+    const nowForWeights = Date.now();
+    for (const candidatePool of poolsToTry) {
+        const isSafePool = candidatePool === contextResult.safe;
+        const candidatesForSelect = avoidAntigravityOnRetry
+            ? preferNonAntigravityWhenPossible(candidatePool)
+            : candidatePool;
+        if (leaseResult.preferredRuntimeKey && !leaseResult.pinnedStrict) {
+            const preferredCandidates = candidatesForSelect.filter((key) => isAntigravityGeminiModelKey(key, deps) && extractLeaseRuntimeKey(key, deps) === leaseResult.preferredRuntimeKey);
+            if (preferredCandidates.length > 0) {
+                const preferredProviderKey = selectProviderKeyFromCandidatePool({
+                    routeName,
+                    tier,
+                    stickyKey,
+                    candidates: preferredCandidates,
+                    isSafePool,
+                    deps,
+                    options,
+                    contextResult,
+                    warnRatio,
+                    excludedKeys,
+                    isRecoveryAttempt,
+                    now,
+                    nowForWeights,
+                    healthWeightedCfg,
+                    contextWeightedCfg
+                });
+                if (preferredProviderKey) {
+                    return { providerKey: preferredProviderKey, poolTargets: tier.targets, tierId: tier.id };
+                }
+            }
+        }
+        const providerKey = selectProviderKeyFromCandidatePool({
+            routeName,
+            tier,
+            stickyKey,
+            candidates: candidatesForSelect,
+            isSafePool,
+            deps,
+            options,
+            contextResult,
+            warnRatio,
+            excludedKeys,
+            isRecoveryAttempt,
+            now,
+            nowForWeights,
+            healthWeightedCfg,
+            contextWeightedCfg
+        });
+        if (providerKey) {
+            return { providerKey, poolTargets: tier.targets, tierId: tier.id };
+        }
+    }
+    return {
+        providerKey: null,
+        poolTargets: tier.targets,
+        tierId: tier.id,
+        failureHint: describeAttempt(routeName, tier.id, contextResult)
+    };
+}
+function recordAliasQueueFailuresFromExcludedKeys(excludedKeys, orderedTargets, deps) {
+    const store = deps.aliasQueueStore;
+    if (!store || !excludedKeys || excludedKeys.size === 0) {
+        return;
+    }
+    if (!Array.isArray(orderedTargets) || orderedTargets.length === 0) {
+        return;
+    }
+    for (const ex of excludedKeys) {
+        if (!ex || typeof ex !== 'string')
+            continue;
+        const providerId = extractProviderId(ex) ?? '';
+        if (!providerId)
+            continue;
+        const strategy = resolveAliasSelectionStrategy(providerId, deps.loadBalancer.getPolicy().aliasSelection);
+        if (strategy !== 'sticky-queue')
+            continue;
+        const modelId = getProviderModelId(ex, deps.providerRegistry) ?? '';
+        if (!modelId)
+            continue;
+        const groupCandidates = orderedTargets.filter((key) => (extractProviderId(key) ?? '') === providerId && (getProviderModelId(key, deps.providerRegistry) ?? '') === modelId);
+        if (groupCandidates.length < 2)
+            continue;
+        try {
+            pinCandidatesByAliasQueue({
+                queueStore: store,
+                providerId,
+                modelId,
+                candidates: groupCandidates,
+                orderedTargets,
+                excludedProviderKeys: new Set([ex]),
+                aliasOfKey: extractKeyAlias,
+                modelIdOfKey: (key) => getProviderModelId(key, deps.providerRegistry),
+                availabilityCheck: () => true
+            });
+        }
+        catch {
+            // best-effort: alias queue rotation must not block selection
+        }
+    }
+}
+function buildContextCandidatePools(result) {
+    const ordered = [];
+    if (result.safe.length) {
+        ordered.push(result.safe);
+    }
+    if (result.risky.length) {
+        ordered.push(result.risky);
+    }
+    return ordered;
+}
+function describeAttempt(routeName, poolId, result) {
+    const prefix = poolId ? `${routeName}:${poolId}` : routeName;
+    if (result.safe.length > 0) {
+        return `${prefix}:health`;
+    }
+    if (result.risky.length > 0) {
+        return `${prefix}:context_risky`;
+    }
+    if (result.overflow.length > 0) {
+        return `${prefix}:max_context_window`;
+    }
+    return prefix;
+}

package/vendor/@jsonstudio/llms/dist/router/virtual-router/engine-selection.d.ts

@@ -0,0 +1 @@
+export { selectProviderImpl, selectDirectProviderModel, selectFromStickyPool } from './engine/routing-pools/index.js';

package/vendor/@jsonstudio/llms/dist/router/virtual-router/engine-selection.js

@@ -0,0 +1 @@
+export { selectProviderImpl, selectDirectProviderModel, selectFromStickyPool } from './engine/routing-pools/index.js';