@jsonstudio/rcc 0.90.352 → 0.90.364

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

@@ -0,0 +1,55 @@
+import { extractProviderId, getProviderModelId } from './key-parsing.js';
+function resolvePriorityMeta(orderedTargets, providerRegistry) {
+    // Priority mode semantics (strict group priority + alias-level balancing):
+    // - Targets are interpreted as ordered (providerId, modelId) groups.
+    // - Group base priorities: 100, 90, 80, ... (step=10) by appearance order.
+    // - Within a group (different auth aliases), base scores: 100, 99, 98, ... (step=1).
+    //
+    // Group selection is strict: always use the best group until it is unavailable.
+    // Alias selection is balanced within the chosen group (RR / health-weighted / context-weighted).
+    const meta = new Map();
+    if (!Array.isArray(orderedTargets) || orderedTargets.length === 0) {
+        return meta;
+    }
+    let groupIndex = -1;
+    let aliasOffset = 0;
+    let lastGroupKey = '';
+    for (const key of orderedTargets) {
+        const providerId = extractProviderId(key) ?? '';
+        const modelId = getProviderModelId(key, providerRegistry) ?? '';
+        const groupKey = `${providerId}::${modelId}`;
+        if (groupKey !== lastGroupKey) {
+            groupIndex += 1;
+            aliasOffset = 0;
+            lastGroupKey = groupKey;
+        }
+        const groupBase = 100 - groupIndex * 10;
+        const base = groupBase - aliasOffset;
+        meta.set(key, { groupId: `${providerId}.${modelId}`, groupBase, base });
+        aliasOffset += 1;
+    }
+    return meta;
+}
+export function pickPriorityGroup(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 (!availabilityCheck(key))
+            continue;
+        const m = meta.get(key);
+        if (!m)
+            continue;
+        const penalty = penalties ? Math.max(0, Math.floor(penalties[key] ?? 0)) : 0;
+        const score = m.base - penalty;
+        if (score > bestScore) {
+            bestScore = score;
+            bestGroupId = m.groupId;
+        }
+    }
+    if (!bestGroupId)
+        return null;
+    const groupCandidates = candidates.filter((key) => meta.get(key)?.groupId === bestGroupId);
+    return groupCandidates.length ? { groupId: bestGroupId, groupCandidates } : null;
+}

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

@@ -0,0 +1,10 @@
+import type { SelectionDeps } from './selection-deps.js';
+export declare function isAntigravityGeminiModelKey(providerKey: string, deps: SelectionDeps): boolean;
+export declare function extractLeaseRuntimeKey(providerKey: string, deps: SelectionDeps): string | null;
+export declare function applyAntigravityAliasSessionLeases(targets: string[], deps: SelectionDeps, metadata: unknown): {
+    targets: string[];
+    blocked: number;
+    preferredPinned: boolean;
+    pinnedStrict: boolean;
+    preferredRuntimeKey?: string;
+};

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

@@ -0,0 +1,231 @@
+import { getProviderModelId, extractProviderId } from './key-parsing.js';
+import { lookupAntigravityPinnedAliasForSessionIdWithNative, unpinAntigravitySessionAliasForSessionIdWithNative } from './native-router-hotpath.js';
+import { lookupAntigravityPinnedAliasForSessionId, unpinAntigravitySessionAliasForSessionId } from '../../../conversion/compat/antigravity-session-signature.js';
+const DEFAULT_ANTIGRAVITY_ALIAS_SESSION_COOLDOWN_MS = 5 * 60_000;
+export function isAntigravityGeminiModelKey(providerKey, deps) {
+    if ((extractProviderId(providerKey) ?? '') !== 'antigravity') {
+        return false;
+    }
+    const modelId = getProviderModelId(providerKey, deps.providerRegistry) ?? '';
+    return modelId.trim().toLowerCase().startsWith('gemini-');
+}
+function extractAntigravityRuntimeBase(providerKey) {
+    const value = typeof providerKey === 'string' ? providerKey.trim() : '';
+    if (!value)
+        return null;
+    const firstDot = value.indexOf('.');
+    if (firstDot <= 0 || firstDot === value.length - 1)
+        return null;
+    const secondDot = value.indexOf('.', firstDot + 1);
+    if (secondDot <= firstDot + 1)
+        return null;
+    const providerId = value.slice(0, firstDot);
+    const alias = value.slice(firstDot + 1, secondDot);
+    if (!providerId || !alias)
+        return null;
+    return `${providerId}.${alias}`;
+}
+function buildAntigravityLeaseRuntimeKey(runtimeBase) {
+    return `${runtimeBase}::gemini`;
+}
+function isAntigravityGeminiSessionBindingDisabled(metadata) {
+    if (!metadata || typeof metadata !== 'object') {
+        return false;
+    }
+    const rtRaw = metadata.__rt;
+    if (!rtRaw || typeof rtRaw !== 'object' || Array.isArray(rtRaw)) {
+        return false;
+    }
+    const rt = rtRaw;
+    if (rt.disableAntigravitySessionBinding === true) {
+        return true;
+    }
+    const mode = rt.antigravitySessionBinding;
+    if (mode === false) {
+        return true;
+    }
+    if (typeof mode === 'string' && ['0', 'false', 'off', 'disabled', 'none'].includes(mode.trim().toLowerCase())) {
+        return true;
+    }
+    return false;
+}
+function resolveSessionScopeKey(metadata) {
+    if (!metadata || typeof metadata !== 'object') {
+        return null;
+    }
+    const record = metadata;
+    const sessionId = typeof record.sessionId === 'string' ? record.sessionId.trim() : '';
+    if (sessionId) {
+        return `session:${sessionId}`;
+    }
+    const conversationId = typeof record.conversationId === 'string' ? record.conversationId.trim() : '';
+    if (conversationId) {
+        return `conversation:${conversationId}`;
+    }
+    const antigravitySessionId = typeof record.antigravitySessionId === 'string'
+        ? String(record.antigravitySessionId).trim()
+        : '';
+    if (antigravitySessionId) {
+        return `session:${antigravitySessionId}`;
+    }
+    return null;
+}
+function buildScopedSessionKey(sessionKey) {
+    return `${sessionKey}::gemini`;
+}
+export function extractLeaseRuntimeKey(providerKey, deps) {
+    const base = extractAntigravityRuntimeBase(providerKey);
+    if (!base)
+        return null;
+    if ((extractProviderId(providerKey) ?? '') !== 'antigravity')
+        return base;
+    if (!isAntigravityGeminiModelKey(providerKey, deps)) {
+        return null;
+    }
+    return buildAntigravityLeaseRuntimeKey(base);
+}
+export function applyAntigravityAliasSessionLeases(targets, deps, metadata) {
+    if (!Array.isArray(targets) || targets.length === 0) {
+        return { targets, blocked: 0, preferredPinned: false, pinnedStrict: false };
+    }
+    if (isAntigravityGeminiSessionBindingDisabled(metadata)) {
+        return { targets, blocked: 0, preferredPinned: false, pinnedStrict: false };
+    }
+    const leaseStore = deps.antigravityAliasLeaseStore;
+    const sessionAliasStore = deps.antigravitySessionAliasStore;
+    if (!leaseStore || !sessionAliasStore) {
+        return { targets, blocked: 0, preferredPinned: false, pinnedStrict: false };
+    }
+    const sessionKey = resolveSessionScopeKey(metadata);
+    if (!sessionKey) {
+        return { targets, blocked: 0, preferredPinned: false, pinnedStrict: false };
+    }
+    const cooldownMs = typeof deps.antigravityAliasReuseCooldownMs === 'number' && Number.isFinite(deps.antigravityAliasReuseCooldownMs)
+        ? Math.max(0, Math.floor(deps.antigravityAliasReuseCooldownMs))
+        : DEFAULT_ANTIGRAVITY_ALIAS_SESSION_COOLDOWN_MS;
+    const now = Date.now();
+    const bindingModeRaw = deps.loadBalancer.getPolicy().aliasSelection
+        ?.antigravitySessionBinding;
+    const strictRequested = typeof bindingModeRaw === 'string' && bindingModeRaw.trim().toLowerCase() === 'strict';
+    const agSessionId = metadata && typeof metadata === 'object' && typeof metadata.antigravitySessionId === 'string'
+        ? String(metadata.antigravitySessionId).trim()
+        : '';
+    const hasAntigravityGeminiTargets = targets.some((key) => isAntigravityGeminiModelKey(key, deps));
+    const lookupPinnedRuntimeKey = () => {
+        if (!(strictRequested && agSessionId && hasAntigravityGeminiTargets)) {
+            return undefined;
+        }
+        const nativePinned = lookupAntigravityPinnedAliasForSessionIdWithNative(agSessionId, { hydrate: true });
+        if (nativePinned && nativePinned.trim()) {
+            return nativePinned.trim();
+        }
+        const persistedPinned = lookupAntigravityPinnedAliasForSessionId(agSessionId, { hydrate: true });
+        if (!persistedPinned || !persistedPinned.trim()) {
+            return undefined;
+        }
+        return persistedPinned.trim();
+    };
+    let pinnedRuntimeKey = lookupPinnedRuntimeKey();
+    const pinnedLeaseKey = pinnedRuntimeKey ? buildAntigravityLeaseRuntimeKey(pinnedRuntimeKey) : undefined;
+    if (pinnedRuntimeKey && deps.quotaView && agSessionId) {
+        const pinnedKeys = targets.filter((key) => isAntigravityGeminiModelKey(key, deps) && extractLeaseRuntimeKey(key, deps) === pinnedLeaseKey);
+        if (pinnedKeys.length > 0) {
+            const allOutOfPool = pinnedKeys.every((key) => deps.quotaView?.(key)?.inPool === false);
+            if (allOutOfPool) {
+                const releasedRuntimeKey = pinnedRuntimeKey;
+                unpinAntigravitySessionAliasForSessionIdWithNative(agSessionId);
+                unpinAntigravitySessionAliasForSessionId(agSessionId);
+                pinnedRuntimeKey = undefined;
+                sessionAliasStore.delete(buildScopedSessionKey(sessionKey));
+                try {
+                    const raw = String(process.env.ROUTECODEX_STAGE_LOG || process.env.RCC_STAGE_LOG || '').trim().toLowerCase();
+                    const enabled = raw !== '' && raw !== '0' && raw !== 'false' && raw !== 'no';
+                    if (enabled) {
+                        console.log('[virtual-router][antigravity-session-binding] unpin', JSON.stringify({ agSessionId, runtimeKey: releasedRuntimeKey }));
+                    }
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+    }
+    const strictBinding = strictRequested && Boolean(pinnedLeaseKey);
+    const geminiSessionKey = buildScopedSessionKey(sessionKey);
+    let preferredGeminiRuntimeKey = pinnedLeaseKey || sessionAliasStore.get(geminiSessionKey);
+    if (preferredGeminiRuntimeKey && !preferredGeminiRuntimeKey.includes('::')) {
+        preferredGeminiRuntimeKey = buildAntigravityLeaseRuntimeKey(preferredGeminiRuntimeKey);
+    }
+    if (preferredGeminiRuntimeKey && !pinnedLeaseKey) {
+        const lease = leaseStore.get(preferredGeminiRuntimeKey);
+        if (lease && lease.sessionKey !== geminiSessionKey && now - lease.lastSeenAt < cooldownMs) {
+            preferredGeminiRuntimeKey = undefined;
+        }
+    }
+    if (deps.quotaView && !pinnedLeaseKey && preferredGeminiRuntimeKey) {
+        const pinnedKeys = targets.filter((key) => isAntigravityGeminiModelKey(key, deps) && extractLeaseRuntimeKey(key, deps) === preferredGeminiRuntimeKey);
+        if (pinnedKeys.length > 0) {
+            const allOutOfPool = pinnedKeys.every((key) => deps.quotaView?.(key)?.inPool === false);
+            if (allOutOfPool) {
+                const releasedRuntimeKey = preferredGeminiRuntimeKey;
+                sessionAliasStore.delete(geminiSessionKey);
+                preferredGeminiRuntimeKey = undefined;
+                try {
+                    const raw = String(process.env.ROUTECODEX_STAGE_LOG || process.env.RCC_STAGE_LOG || '').trim().toLowerCase();
+                    const enabled = raw !== '' && raw !== '0' && raw !== 'false' && raw !== 'no';
+                    if (enabled) {
+                        console.log('[virtual-router][antigravity-session-binding] release', JSON.stringify({ sessionKey: geminiSessionKey, runtimeKey: releasedRuntimeKey }));
+                    }
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+    }
+    const pinnedGemini = preferredGeminiRuntimeKey
+        ? targets.filter((key) => isAntigravityGeminiModelKey(key, deps) && extractLeaseRuntimeKey(key, deps) === preferredGeminiRuntimeKey)
+        : [];
+    const preferredPinned = pinnedGemini.length > 0;
+    const pinnedSet = preferredPinned ? new Set([...pinnedGemini]) : null;
+    const candidates = preferredPinned
+        ? [...pinnedGemini, ...targets.filter((key) => !pinnedSet.has(key))]
+        : targets;
+    const pinnedStrict = strictBinding && Boolean(preferredGeminiRuntimeKey);
+    let blocked = 0;
+    const filtered = candidates.filter((key) => {
+        const providerId = extractProviderId(key);
+        if (providerId !== 'antigravity') {
+            return true;
+        }
+        if (!isAntigravityGeminiModelKey(key, deps)) {
+            return true;
+        }
+        const scopedSessionKey = geminiSessionKey;
+        const runtimeKey = extractLeaseRuntimeKey(key, deps);
+        if (!runtimeKey) {
+            return true;
+        }
+        if (pinnedStrict) {
+            if (!isAntigravityGeminiModelKey(key, deps)) {
+                return true;
+            }
+            if (preferredGeminiRuntimeKey && runtimeKey !== preferredGeminiRuntimeKey) {
+                return false;
+            }
+        }
+        const lease = leaseStore.get(runtimeKey);
+        if (!lease) {
+            return true;
+        }
+        if (lease.sessionKey === scopedSessionKey) {
+            return true;
+        }
+        if (now - lease.lastSeenAt >= cooldownMs) {
+            return true;
+        }
+        blocked += 1;
+        return false;
+    });
+    return { targets: filtered, blocked, preferredPinned, pinnedStrict, preferredRuntimeKey: preferredGeminiRuntimeKey };
+}

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

@@ -0,0 +1,4 @@
+export declare function shouldAvoidAllAntigravityOnRetry(metadata: unknown): boolean;
+export declare function shouldAvoidAntigravityAfterRepeatedError(metadata: unknown): boolean;
+export declare function preferNonAntigravityWhenPossible(candidates: string[]): string[];
+export declare function extractNonAntigravityTargets(targets: string[]): string[];

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

@@ -0,0 +1,43 @@
+import { splitAntigravityTargets } from './native-router-hotpath.js';
+export function shouldAvoidAllAntigravityOnRetry(metadata) {
+    if (!metadata || typeof metadata !== 'object') {
+        return false;
+    }
+    const rtRaw = metadata.__rt;
+    if (!rtRaw || typeof rtRaw !== 'object' || Array.isArray(rtRaw)) {
+        return false;
+    }
+    const rt = rtRaw;
+    return rt.antigravityAvoidAllOnRetry === true;
+}
+export function shouldAvoidAntigravityAfterRepeatedError(metadata) {
+    if (!metadata || typeof metadata !== 'object') {
+        return false;
+    }
+    const rtRaw = metadata.__rt;
+    if (!rtRaw || typeof rtRaw !== 'object' || Array.isArray(rtRaw)) {
+        return false;
+    }
+    const rt = rtRaw;
+    if (rt.antigravityAvoidAllOnRetry === true) {
+        return true;
+    }
+    const signature = typeof rt.antigravityRetryErrorSignature === 'string' ? rt.antigravityRetryErrorSignature.trim() : '';
+    const consecutive = typeof rt.antigravityRetryErrorConsecutive === 'number' && Number.isFinite(rt.antigravityRetryErrorConsecutive)
+        ? Math.max(0, Math.floor(rt.antigravityRetryErrorConsecutive))
+        : 0;
+    return signature.length > 0 && signature !== 'unknown' && consecutive >= 2;
+}
+export function preferNonAntigravityWhenPossible(candidates) {
+    if (!Array.isArray(candidates) || candidates.length < 2) {
+        return candidates;
+    }
+    const nonAntigravity = splitAntigravityTargets(candidates).nonAntigravity;
+    return nonAntigravity.length > 0 ? nonAntigravity : candidates;
+}
+export function extractNonAntigravityTargets(targets) {
+    if (!Array.isArray(targets) || targets.length === 0) {
+        return [];
+    }
+    return splitAntigravityTargets(targets).nonAntigravity;
+}

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

@@ -0,0 +1,29 @@
+import type { ContextAdvisorResult } from '../context-advisor.js';
+import { type ResolvedContextWeightedConfig } from '../context-weighted.js';
+import { type ResolvedHealthWeightedConfig } from '../health-weighted.js';
+import type { RoutePoolTier } from '../types.js';
+import type { SelectionDeps, TrySelectFromTierOptions } from './selection-deps.js';
+import { type ResolvedTierLoadBalancing } from './tier-load-balancing.js';
+export declare function selectProviderKeyWithQuotaBuckets(opts: {
+    routeName: string;
+    tier: RoutePoolTier;
+    stickyKey: string | undefined;
+    candidates: string[];
+    isSafePool: boolean;
+    deps: SelectionDeps;
+    options: TrySelectFromTierOptions;
+    contextResult: ContextAdvisorResult;
+    warnRatio: number;
+    excludedKeys: Set<string>;
+    isRecoveryAttempt: boolean;
+    now: number;
+    nowForWeights: number;
+    healthWeightedCfg: ResolvedHealthWeightedConfig;
+    contextWeightedCfg: ResolvedContextWeightedConfig;
+    tierLoadBalancing: ResolvedTierLoadBalancing;
+    quotaView: NonNullable<SelectionDeps['quotaView']>;
+    isAvailable: (key: string) => boolean;
+    selectFirstAvailable: (keys: string[]) => string | null;
+    applyAliasStickyQueuePinning: (candidates: string[]) => string[];
+    preferAntigravityAliasesOnRetry: (candidates: string[]) => string[];
+}): string | null;

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

@@ -0,0 +1,194 @@
+import { computeContextMultiplier } from '../context-weighted.js';
+import { computeHealthWeight } from '../health-weighted.js';
+import { buildQuotaBuckets } from './native-router-hotpath.js';
+import { computeContextWeightMultipliers } from './context-weight-multipliers.js';
+import { buildCandidateWeights, buildGroupWeights, hasNonUniformWeights } from './tier-load-balancing.js';
+import { pickPriorityGroup } from './tier-priority.js';
+import { extractProviderId, getProviderModelId } from './key-parsing.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;
+}
+export function selectProviderKeyWithQuotaBuckets(opts) {
+    const { routeName, tier, stickyKey, candidates, isSafePool, deps, options, contextResult, warnRatio, isRecoveryAttempt, now, nowForWeights, healthWeightedCfg, contextWeightedCfg, tierLoadBalancing, quotaView, isAvailable, selectFirstAvailable, applyAliasStickyQueuePinning, preferAntigravityAliasesOnRetry } = opts;
+    const bucketInputs = candidates.map((key, order) => {
+        const entry = quotaView(key);
+        const penaltyRaw = entry?.selectionPenalty;
+        return {
+            key,
+            order,
+            hasQuota: Boolean(entry),
+            inPool: entry ? entry.inPool !== false : true,
+            ...(entry && typeof entry.cooldownUntil === 'number' ? { cooldownUntil: entry.cooldownUntil } : {}),
+            ...(entry && typeof entry.blacklistUntil === 'number' ? { blacklistUntil: entry.blacklistUntil } : {}),
+            ...(entry && typeof entry.priorityTier === 'number' ? { priorityTier: entry.priorityTier } : {}),
+            ...(typeof penaltyRaw === 'number' ? { selectionPenalty: penaltyRaw } : {})
+        };
+    });
+    const { priorities: sortedPriorities, buckets } = buildQuotaBuckets(bucketInputs, now);
+    for (const priority of sortedPriorities) {
+        const bucket = buckets.get(priority) ?? [];
+        if (!bucket.length) {
+            continue;
+        }
+        bucket.sort((a, b) => a.order - b.order);
+        let bucketCandidates = bucket.map((item) => item.key);
+        if (bucketCandidates.length === 1) {
+            return bucketCandidates[0] ?? null;
+        }
+        if (isRecoveryAttempt) {
+            bucketCandidates = preferAntigravityAliasesOnRetry(bucketCandidates);
+        }
+        bucketCandidates = applyAliasStickyQueuePinning(bucketCandidates);
+        const quotaWeights = {};
+        for (const item of bucket) {
+            if (healthWeightedCfg.enabled) {
+                const entry = quotaView(item.key);
+                const { weight } = computeHealthWeight(entry, nowForWeights, healthWeightedCfg);
+                quotaWeights[item.key] = weight;
+            }
+            else {
+                quotaWeights[item.key] = Math.max(1, Math.floor(100 / (1 + Math.max(0, item.penalty))));
+            }
+        }
+        const contextWeights = (() => {
+            if (!isSafePool || !contextWeightedCfg.enabled) {
+                return undefined;
+            }
+            const ctx = computeContextWeightMultipliers({
+                candidates: bucketCandidates,
+                usage: contextResult.usage,
+                warnRatio,
+                cfg: contextWeightedCfg
+            });
+            if (!ctx) {
+                return undefined;
+            }
+            const out = {};
+            for (const key of bucketCandidates) {
+                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 bucketWeights = buildCandidateWeights({
+            candidates: bucketCandidates,
+            providerRegistry: deps.providerRegistry,
+            staticWeights: tierLoadBalancing.weights,
+            dynamicWeights: Object.keys(quotaWeights).length || contextWeights
+                ? Object.fromEntries(bucketCandidates.map((key) => {
+                    const quotaWeight = quotaWeights[key];
+                    const contextWeight = contextWeights?.[key];
+                    const combined = typeof contextWeight === 'number'
+                        ? Math.max(1, Math.round((quotaWeight ?? 1) * contextWeight))
+                        : quotaWeight;
+                    return [key, combined ?? 1];
+                }))
+                : undefined
+        });
+        if (tier.mode === 'priority') {
+            if (!isRecoveryAttempt) {
+                const group = pickPriorityGroup({
+                    candidates: bucketCandidates,
+                    orderedTargets: tier.targets,
+                    providerRegistry: deps.providerRegistry,
+                    availabilityCheck: isAvailable
+                });
+                if (!group) {
+                    continue;
+                }
+                const groupWeights = {};
+                for (const key of group.groupCandidates) {
+                    groupWeights[key] = bucketWeights?.[key] ?? 1;
+                }
+                const allowGrouped = !hasNonUniformWeights(group.groupCandidates, bucketWeights);
+                if (allowGrouped && tierLoadBalancing.strategy !== 'sticky') {
+                    const groups = buildPrimaryTargetGroups(group.groupCandidates, deps);
+                    if (groups.size > 0) {
+                        const groupWeightMap = buildGroupWeights(groups, tierLoadBalancing.weights);
+                        const selected = deps.loadBalancer.selectGrouped({
+                            routeName: `${routeName}:${tier.id}:priority:${priority}:group:${group.groupId}`,
+                            groups,
+                            stickyKey: options.allowAliasRotation ? undefined : stickyKey,
+                            weights: groupWeightMap,
+                            availabilityCheck: isAvailable
+                        }, 'round-robin');
+                        if (selected) {
+                            return selected;
+                        }
+                    }
+                }
+                const selected = deps.loadBalancer.select({
+                    routeName: `${routeName}:${tier.id}:priority:${priority}:group:${group.groupId}`,
+                    candidates: group.groupCandidates,
+                    stickyKey: options.allowAliasRotation ? undefined : stickyKey,
+                    weights: groupWeights,
+                    availabilityCheck: isAvailable
+                }, 'round-robin');
+                if (selected) {
+                    return selected;
+                }
+                continue;
+            }
+            const recovered = selectFirstAvailable(bucketCandidates);
+            if (recovered)
+                return recovered;
+            continue;
+        }
+        if (isRecoveryAttempt) {
+            const recovered = selectFirstAvailable(bucketCandidates);
+            if (recovered)
+                return recovered;
+            continue;
+        }
+        const allowGrouped = !hasNonUniformWeights(bucketCandidates, bucketWeights);
+        if (allowGrouped && tierLoadBalancing.strategy !== 'sticky') {
+            const groups = buildPrimaryTargetGroups(bucketCandidates, deps);
+            if (groups.size > 0) {
+                const groupWeightMap = buildGroupWeights(groups, tierLoadBalancing.weights);
+                const selected = deps.loadBalancer.selectGrouped({
+                    routeName: `${routeName}:${tier.id}:${priority}`,
+                    groups,
+                    stickyKey: options.allowAliasRotation ? undefined : stickyKey,
+                    weights: groupWeightMap,
+                    availabilityCheck: isAvailable
+                }, tier.mode === 'round-robin' ? 'round-robin' : tierLoadBalancing.strategy);
+                if (selected) {
+                    return selected;
+                }
+            }
+        }
+        const selected = deps.loadBalancer.select({
+            routeName: `${routeName}:${tier.id}`,
+            candidates: bucketCandidates,
+            stickyKey: options.allowAliasRotation ? undefined : stickyKey,
+            weights: bucketWeights,
+            availabilityCheck: isAvailable
+        }, tier.mode === 'round-robin' ? 'round-robin' : tierLoadBalancing.strategy);
+        if (selected) {
+            return selected;
+        }
+    }
+    return null;
+}

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

@@ -0,0 +1,22 @@
+import type { ContextAdvisorResult } from '../context-advisor.js';
+import type { ResolvedHealthWeightedConfig } from '../health-weighted.js';
+import type { RoutePoolTier } from '../types.js';
+import type { ResolvedContextWeightedConfig } from '../context-weighted.js';
+import type { SelectionDeps, TrySelectFromTierOptions } from './selection-deps.js';
+export declare function selectProviderKeyFromCandidatePool(opts: {
+    routeName: string;
+    tier: RoutePoolTier;
+    stickyKey: string | undefined;
+    candidates: string[];
+    isSafePool: boolean;
+    deps: SelectionDeps;
+    options: TrySelectFromTierOptions;
+    contextResult: ContextAdvisorResult;
+    warnRatio: number;
+    excludedKeys: Set<string>;
+    isRecoveryAttempt: boolean;
+    now: number;
+    nowForWeights: number;
+    healthWeightedCfg: ResolvedHealthWeightedConfig;
+    contextWeightedCfg: ResolvedContextWeightedConfig;
+}): string | null;