@jsonstudio/llms 0.6.1449 → 0.6.1643

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,173 @@ 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}`;
+    }
+    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 +283,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 +343,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 = [];
@@ -167,10 +401,20 @@ export function trySelectFromTier(routeName, tier, stickyKey, estimatedTokens, f
         }
     }
     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.js

@@ -49,7 +49,7 @@ export function selectProviderImpl(requestedRoute, metadata, classification, fea
         stickyResolution = resolveInstructionTarget(state.stickyTarget, deps.providerRegistry);
         if (stickyResolution && stickyResolution.mode === 'exact') {
             const stickyKey = stickyResolution.keys[0];
-            if (deps.healthManager.isAvailable(stickyKey) &&
+            if ((deps.quotaView ? true : deps.healthManager.isAvailable(stickyKey)) &&
                 !excludedProviderKeys.has(stickyKey) &&
                 !deps.isProviderCoolingDown(stickyKey) &&
                 isAllowedByQuota(stickyKey)) {
@@ -62,7 +62,7 @@ export function selectProviderImpl(requestedRoute, metadata, classification, fea
             }
         }
         if (stickyResolution && stickyResolution.mode === 'filter' && stickyResolution.keys.length > 0) {
-            const liveKeys = stickyResolution.keys.filter((key) => deps.healthManager.isAvailable(key) &&
+            const liveKeys = stickyResolution.keys.filter((key) => (deps.quotaView ? true : deps.healthManager.isAvailable(key)) &&
                 !excludedProviderKeys.has(key) &&
                 !deps.isProviderCoolingDown(key) &&
                 isAllowedByQuota(key));

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

@@ -1,4 +1,4 @@
-import { type RoutingDecision, type RoutingDiagnostics, type StopMessageStateSnapshot, type RouterMetadataInput, type VirtualRouterConfig, type TargetMetadata, type ProviderFailureEvent, type ProviderErrorEvent, type VirtualRouterHealthStore } from './types.js';
+import { type RoutingDecision, type RoutingDiagnostics, type StopMessageStateSnapshot, type RouterMetadataInput, type VirtualRouterConfig, type TargetMetadata, type ProviderFailureEvent, type ProviderErrorEvent, type ProviderSuccessEvent, type VirtualRouterHealthStore } from './types.js';
 import type { ProcessedRequest, StandardizedRequest } from '../../conversion/hub/types/standardized.js';
 import { type RoutingInstructionState } from './routing-instructions.js';
 import type { ProviderQuotaView } from './types.js';
@@ -18,6 +18,10 @@ export declare class VirtualRouterEngine {
     private contextRouting;
     private routeStats;
     private readonly aliasQueueStore;
+    private readonly antigravityAliasLeaseStore;
+    private readonly antigravitySessionAliasStore;
+    private antigravityAliasReuseCooldownMs;
+    private antigravityLeasePersistence;
     private readonly debug;
     private healthConfig;
     private readonly statsCenter;
@@ -46,6 +50,7 @@ export declare class VirtualRouterEngine {
     getStopMessageState(metadata: RouterMetadataInput): StopMessageStateSnapshot | null;
     handleProviderFailure(event: ProviderFailureEvent): void;
     handleProviderError(event: ProviderErrorEvent): void;
+    handleProviderSuccess(event: ProviderSuccessEvent): void;
     getStatus(): {
         routes: Record<string, {
             providers: string[];
@@ -65,6 +70,16 @@ export declare class VirtualRouterEngine {
     private providerHealthConfig;
     private resolveStickyKey;
     private resolveSessionScope;
+    private resolveAntigravityAliasReuseCooldownMs;
+    private resolveAntigravityLeaseScope;
+    private buildScopedSessionKey;
+    private buildAntigravityLeaseRuntimeKey;
+    private extractRuntimeKey;
+    private recordAntigravitySessionLease;
+    private resolveAntigravityAliasLeasePersistPath;
+    private hydrateAntigravityAliasLeaseStoreIfNeeded;
+    private scheduleAntigravityAliasLeaseStoreFlush;
+    private flushAntigravityAliasLeaseStoreSync;
     private resolveStopMessageScope;
     private getRoutingInstructionState;
     private buildMetadataInstructions;