@jsonstudio/rcc 0.90.367 → 0.90.429

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

@@ -1,352 +0,0 @@
-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/llmswitch-core/dist/router/virtual-router/engine-selection/tier-selection.d.ts

@@ -1,3 +0,0 @@
-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/llmswitch-core/dist/router/virtual-router/engine-selection/tier-selection.js

@@ -1,309 +0,0 @@
-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/llmswitch-core/dist/router/virtual-router/engine-selection.d.ts

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

package/vendor/llmswitch-core/dist/router/virtual-router/engine-selection.js

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