@jsonstudio/llms 0.6.1462 → 0.6.1733

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

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

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

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

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

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

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

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

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

@@ -4,6 +4,34 @@ import { resolveHealthWeightedConfig } from '../health-weighted.js';
 import { pinCandidatesByAliasQueue, resolveAliasSelectionStrategy } from './alias-selection.js';
 import { extractKeyAlias, extractKeyIndex, extractProviderId, getProviderModelId } from './key-parsing.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;
@@ -15,6 +43,27 @@ function shouldAvoidAllAntigravityOnRetry(metadata) {
     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;
@@ -46,9 +95,181 @@ function extractNonAntigravityTargets(targets) {
     }
     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 && !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 };
+}
 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')
@@ -70,10 +291,14 @@ export function trySelectFromTier(routeName, tier, stickyKey, estimatedTokens, f
     }
     const singleCandidateFallback = targets.length === 1 ? targets[0] : undefined;
     if (targets.length > 0) {
-        // 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));
+        // 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) => {
@@ -126,6 +351,23 @@ export function trySelectFromTier(routeName, tier, stickyKey, estimatedTokens, f
     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 = [];
@@ -142,35 +384,54 @@ export function trySelectFromTier(routeName, tier, stickyKey, estimatedTokens, f
         }
         targets = filtered;
     }
-    if (features.hasImageAttachment && (routeName === DEFAULT_ROUTE || routeName === 'thinking')) {
-        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);
+    if (features.hasImageAttachment) {
+        const kimiTargets = targets.filter((key) => {
+            const modelId = getProviderModelId(key, deps.providerRegistry) ?? '';
+            return modelId.trim().toLowerCase() === 'kimi-k2.5';
+        });
+        if (kimiTargets.length) {
+            targets = kimiTargets;
+        }
+        else if (routeName === DEFAULT_ROUTE || routeName === 'thinking') {
+            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);
+                    }
                 }
-                else {
+                catch {
                     fallthrough.push(key);
                 }
             }
-            catch {
-                fallthrough.push(key);
+            if (prioritized.length) {
+                targets = prioritized;
             }
         }
-        if (prioritized.length) {
-            targets = prioritized;
-        }
     }
     if (!targets.length) {
-        return { providerKey: null, poolTargets: [], tierId: tier.id, failureHint: `${routeName}:${tier.id}:empty` };
+        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));
-    const prioritizedPools = buildContextCandidatePools(contextResult);
+    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

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

@@ -1,13 +1 @@
-import type { ClassificationResult, RouterMetadataInput, RoutingFeatures } from './types.js';
-import type { RoutingInstructionState } from './routing-instructions.js';
-import type { SelectionDeps } from './engine-selection/selection-deps.js';
-export { selectDirectProviderModel } from './engine-selection/direct-provider-model.js';
-export { selectFromStickyPool } from './engine-selection/sticky-pool.js';
-export declare function selectProviderImpl(requestedRoute: string, metadata: RouterMetadataInput, classification: ClassificationResult, features: RoutingFeatures, activeState: RoutingInstructionState, deps: SelectionDeps, options?: {
-    routingState?: RoutingInstructionState;
-}): {
-    providerKey: string;
-    routeUsed: string;
-    pool: string[];
-    poolId?: string;
-};
+export { selectProviderImpl, selectDirectProviderModel, selectFromStickyPool } from './engine/routing-pools/index.js';