@jsonstudio/llms 0.6.2172 → 0.6.2979

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

@@ -0,0 +1,27 @@
+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';
+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;
+    quotaView: NonNullable<SelectionDeps['quotaView']>;
+    isAvailable: (key: string) => boolean;
+    selectFirstAvailable: (keys: string[]) => string | null;
+    applyAliasStickyQueuePinning: (candidates: string[]) => string[];
+    preferAntigravityAliasesOnRetry: (candidates: string[]) => string[];
+}): string | null;

package/dist/router/virtual-router/engine-selection/tier-selection-quota-integration.js

@@ -0,0 +1,116 @@
+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 { pickPriorityGroup } from './tier-priority.js';
+export function selectProviderKeyWithQuotaBuckets(opts) {
+    const { routeName, tier, stickyKey, candidates, isSafePool, deps, options, contextResult, warnRatio, isRecoveryAttempt, now, nowForWeights, healthWeightedCfg, contextWeightedCfg, 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 bucketWeights = {};
+        for (const item of bucket) {
+            if (healthWeightedCfg.enabled) {
+                const entry = quotaView(item.key);
+                const { weight } = computeHealthWeight(entry, nowForWeights, healthWeightedCfg);
+                bucketWeights[item.key] = weight;
+            }
+            else {
+                bucketWeights[item.key] = Math.max(1, Math.floor(100 / (1 + Math.max(0, item.penalty))));
+            }
+        }
+        if (isSafePool && contextWeightedCfg.enabled) {
+            const ctx = computeContextWeightMultipliers({
+                candidates: bucketCandidates,
+                usage: contextResult.usage,
+                warnRatio,
+                cfg: contextWeightedCfg
+            });
+            if (ctx) {
+                for (const key of bucketCandidates) {
+                    const m = computeContextMultiplier({
+                        effectiveSafeRefTokens: ctx.ref,
+                        effectiveSafeTokens: ctx.eff[key] ?? 1,
+                        cfg: contextWeightedCfg
+                    });
+                    bucketWeights[key] = Math.max(1, Math.round((bucketWeights[key] ?? 1) * m));
+                }
+            }
+        }
+        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 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 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' : undefined);
+        if (selected) {
+            return selected;
+        }
+    }
+    return null;
+}

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

@@ -1,5 +1,5 @@
 import type { ContextAdvisorResult } from '../context-advisor.js';
-import { type ResolvedHealthWeightedConfig } from '../health-weighted.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';

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

@@ -1,9 +1,9 @@
 import { computeContextMultiplier } from '../context-weighted.js';
-import { computeHealthWeight } from '../health-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 { pickPriorityGroup } from './tier-priority.js';
+import { selectProviderKeyWithQuotaBuckets } from './tier-selection-quota-integration.js';
 function applyAliasStickyQueuePinning(opts) {
     const { candidates, orderedTargets, deps, excludedKeys } = opts;
     if (!Array.isArray(candidates) || candidates.length < 2) {
@@ -250,135 +250,35 @@ export function selectProviderKeyFromCandidatePool(opts) {
             availabilityCheck: isAvailable
         }, tier.mode === 'round-robin' ? 'round-robin' : undefined);
     }
-    const buckets = new Map();
-    let order = 0;
-    for (const key of candidates) {
-        const entry = quotaView(key);
-        if (!entry) {
-            const list = buckets.get(100) ?? [];
-            list.push({ key, penalty: 0, order: order++ });
-            buckets.set(100, list);
-            continue;
-        }
-        if (!entry.inPool) {
-            continue;
-        }
-        if (entry.cooldownUntil && entry.cooldownUntil > now) {
-            continue;
-        }
-        if (entry.blacklistUntil && entry.blacklistUntil > now) {
-            continue;
-        }
-        const tierPriority = typeof entry.priorityTier === 'number' && Number.isFinite(entry.priorityTier) ? entry.priorityTier : 100;
-        const penaltyRaw = entry.selectionPenalty;
-        const penalty = typeof penaltyRaw === 'number' && Number.isFinite(penaltyRaw) && penaltyRaw > 0 ? Math.floor(penaltyRaw) : 0;
-        const list = buckets.get(tierPriority) ?? [];
-        list.push({ key, penalty, order: order++ });
-        buckets.set(tierPriority, list);
-    }
-    const sortedPriorities = Array.from(buckets.keys()).sort((a, b) => a - b);
-    for (const priority of sortedPriorities) {
-        const bucket = buckets.get(priority) ?? [];
-        if (!bucket.length) {
-            continue;
-        }
-        // Keep candidate ordering stable (config order). Availability/blacklist/cooldown still apply.
-        bucket.sort((a, b) => a.order - b.order);
-        let bucketCandidates = bucket.map((item) => item.key);
-        // Single-provider pool should never be "emptied" by health/cooldown.
-        if (bucketCandidates.length === 1) {
-            return bucketCandidates[0] ?? null;
-        }
-        if (isRecoveryAttempt) {
-            bucketCandidates = preferAntigravityAliasesOnRetry({ candidates: bucketCandidates, excludedKeys, deps });
-        }
-        // Alias-level selection strategy (config-driven).
-        // For configured providers, we stick to one alias globally and rotate only on error/unavailability.
-        bucketCandidates = applyAliasStickyQueuePinning({
-            candidates: bucketCandidates,
+    return selectProviderKeyWithQuotaBuckets({
+        routeName,
+        tier,
+        stickyKey,
+        candidates,
+        isSafePool,
+        deps,
+        options,
+        contextResult,
+        warnRatio,
+        excludedKeys,
+        isRecoveryAttempt,
+        now,
+        nowForWeights,
+        healthWeightedCfg,
+        contextWeightedCfg,
+        quotaView,
+        isAvailable,
+        selectFirstAvailable,
+        applyAliasStickyQueuePinning: (quotaCandidates) => applyAliasStickyQueuePinning({
+            candidates: quotaCandidates,
             orderedTargets: tier.targets,
             deps,
             excludedKeys
-        });
-        const bucketWeights = {};
-        const bucketMultipliers = {};
-        for (const item of bucket) {
-            if (healthWeightedCfg.enabled) {
-                const entry = quotaView(item.key);
-                const { weight, multiplier } = computeHealthWeight(entry, nowForWeights, healthWeightedCfg);
-                bucketWeights[item.key] = weight;
-                bucketMultipliers[item.key] = multiplier;
-            }
-            else {
-                // Legacy: penalty => lower weight, but never zero (unhealthy should still get a chance).
-                bucketWeights[item.key] = Math.max(1, Math.floor(100 / (1 + Math.max(0, item.penalty))));
-                bucketMultipliers[item.key] = 1;
-            }
-        }
-        if (isSafePool && contextWeightedCfg.enabled) {
-            const ctx = computeContextWeightMultipliers({ candidates: bucketCandidates, usage: contextResult.usage, warnRatio, cfg: contextWeightedCfg });
-            if (ctx) {
-                for (const key of bucketCandidates) {
-                    const m = computeContextMultiplier({
-                        effectiveSafeRefTokens: ctx.ref,
-                        effectiveSafeTokens: ctx.eff[key] ?? 1,
-                        cfg: contextWeightedCfg
-                    });
-                    bucketWeights[key] = Math.max(1, Math.round((bucketWeights[key] ?? 1) * m));
-                }
-            }
-        }
-        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 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;
-            // (unreachable) recovery handled above
-        }
-        else {
-            if (isRecoveryAttempt) {
-                const recovered = selectFirstAvailable(bucketCandidates);
-                if (recovered)
-                    return recovered;
-                continue;
-            }
-            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' : undefined);
-            if (selected) {
-                return selected;
-            }
-        }
-    }
-    return null;
+        }),
+        preferAntigravityAliasesOnRetry: (quotaCandidates) => preferAntigravityAliasesOnRetry({
+            candidates: quotaCandidates,
+            excludedKeys,
+            deps
+        })
+    });
 }

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

@@ -5,271 +5,8 @@ import { pinCandidatesByAliasQueue, resolveAliasSelectionStrategy } from './alia
 import { extractKeyAlias, extractKeyIndex, extractProviderId, getProviderModelId } from './key-parsing.js';
 import { providerSupportsMultimodalRequest } from './multimodal-capability.js';
 import { selectProviderKeyFromCandidatePool } from './tier-selection-select.js';
-import { lookupAntigravityPinnedAliasForSessionId, unpinAntigravitySessionAliasForSessionId } from '../../../conversion/compat/antigravity-session-signature.js';
-const DEFAULT_ANTIGRAVITY_ALIAS_SESSION_COOLDOWN_MS = 5 * 60_000;
-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 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;
-}
-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 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;
-}
-function preferNonAntigravityWhenPossible(candidates) {
-    if (!Array.isArray(candidates) || candidates.length < 2) {
-        return candidates;
-    }
-    const nonAntigravity = candidates.filter((key) => (extractProviderId(key) ?? '') !== 'antigravity');
-    return nonAntigravity.length > 0 ? nonAntigravity : candidates;
-}
-function extractNonAntigravityTargets(targets) {
-    if (!Array.isArray(targets) || targets.length === 0) {
-        return [];
-    }
-    return targets.filter((key) => (extractProviderId(key) ?? '') !== 'antigravity');
-}
-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}`;
-    }
-    // Antigravity-Manager alignment: when the client does not provide session_id/conversation_id,
-    // fall back to the derived antigravitySessionId so alias/session binding still works.
-    const antigravitySessionId = typeof record.antigravitySessionId === 'string'
-        ? String(record.antigravitySessionId).trim()
-        : '';
-    if (antigravitySessionId) {
-        return `session:${antigravitySessionId}`;
-    }
-    return null;
-}
-function buildScopedSessionKey(sessionKey) {
-    // Policy: antigravity alias/session binding applies only to Gemini models.
-    return `${sessionKey}::gemini`;
-}
-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);
-}
-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));
-    let pinnedRuntimeKey = strictRequested && agSessionId && hasAntigravityGeminiTargets
-        ? lookupAntigravityPinnedAliasForSessionId(agSessionId, { hydrate: true })
-        : undefined;
-    const pinnedLeaseKey = pinnedRuntimeKey ? buildAntigravityLeaseRuntimeKey(pinnedRuntimeKey) : undefined;
-    // If the pinned alias is completely out of pool (quota exhausted), release the pin so we can rotate.
-    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;
-                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 a previously bound alias is completely out of pool (quota exhausted / blacklisted),
-    // release the binding so the session can rebind to a different alias on the next successful call.
-    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;
-        }
-        // Policy: antigravity alias/session binding applies only to Gemini models.
-        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 };
-}
+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 : [];