@jsonstudio/llms 0.6.1892 → 0.6.2172

package/dist/router/virtual-router/classifier.js

@@ -11,7 +11,6 @@ export class RoutingClassifier {
     }
     classify(features) {
         const lastToolCategory = features.lastAssistantToolCategory;
-        const webSearchDeclared = features.hasWebSearchToolDeclared === true;
         const webSearchIntent = detectWebSearchIntent(features.userTextSample);
         const localToolContinuation = lastToolCategory === 'read' ||
             lastToolCategory === 'write' ||
@@ -49,15 +48,10 @@ export class RoutingClassifier {
             },
             web_search: {
                 // web_search 仅由“当前请求”触发：
-                // - 显式声明 web_search 工具；或
                 // - 用户输入命中联网搜索意图关键词。
-                // 不再使用上一轮 websearch 续写，避免连续轮次被粘住。
-                triggered: !localToolContinuation && (webSearchDeclared || webSearchIntent),
-                reason: webSearchDeclared && webSearchIntent
-                    ? 'web_search:tool+intent'
-                    : webSearchDeclared
-                        ? 'web_search:tool-declared'
-                        : 'web_search:intent-keyword'
+                // 不再使用工具声明或上一轮 websearch 续写来决定路由。
+                triggered: !localToolContinuation && webSearchIntent,
+                reason: 'web_search:intent-keyword'
             },
             search: {
                 // search 路由：仅在上一轮 assistant 使用 search 类工具时继续命中，
@@ -120,13 +114,15 @@ function detectWebSearchIntent(text) {
         return false;
     }
     const normalized = text.toLowerCase();
+    if (isNegativeWebSearchContext(normalized, text)) {
+        return false;
+    }
     const directKeywords = [
         'web search',
         'web_search',
         'websearch',
         'search the web',
         'internet search',
-        'search online',
         '搜索网页',
         '联网搜索',
         '上网搜索',
@@ -139,21 +135,43 @@ function detectWebSearchIntent(text) {
         return true;
     }
     const enVerb = ['search', 'find', 'lookup', 'look up', 'google'];
-    const enNoun = ['web', 'internet', 'online', 'news', 'latest', 'today'];
+    const enNoun = ['web', 'internet', 'online', 'google', 'bing'];
     const hasEnVerb = enVerb.some((keyword) => normalized.includes(keyword));
     const hasEnNoun = enNoun.some((keyword) => normalized.includes(keyword));
     if (hasEnVerb && hasEnNoun) {
         return true;
     }
-    const zhVerb = ['搜索', '查找', '查询', '搜'];
-    const zhNoun = ['网络', '联网', '网页', '新闻', '资讯', '实时', '最新', '今天'];
+    const zhVerb = ['搜索', '查找', '搜', '上网查', '上网搜', '联网查', '联网搜'];
+    const zhNoun = ['网络', '联网', '网页', '网上', '互联网', '谷歌', '百度'];
     const hasZhVerb = zhVerb.some((keyword) => text.includes(keyword));
     const hasZhNoun = zhNoun.some((keyword) => text.includes(keyword));
-    if (text.includes('上网') || (hasZhVerb && hasZhNoun)) {
+    if ((text.includes('上网') || text.includes('联网')) && (text.includes('搜') || text.includes('查'))) {
+        return true;
+    }
+    if (hasZhVerb && hasZhNoun) {
         return true;
     }
     return false;
 }
+function isNegativeWebSearchContext(normalized, originalText) {
+    const englishPatterns = [
+        /prefer\s+resources?\s+over\s+web[\s_-]?search/u,
+        /prefer[\s\S]{0,40}web[\s_-]?search/u,
+        /do\s+not[\s\S]{0,20}web[\s_-]?search/u,
+        /don't[\s\S]{0,20}web[\s_-]?search/u,
+        /without[\s\S]{0,20}web[\s_-]?search/u,
+        /cannot[\s\S]{0,20}web[\s_-]?search/u
+    ];
+    if (englishPatterns.some((pattern) => pattern.test(normalized))) {
+        return true;
+    }
+    const chinesePatterns = [
+        /不能.{0,20}(上网|联网|web[_ -]?search|搜索网页)/u,
+        /不要.{0,20}(上网|联网|web[_ -]?search|搜索网页)/u,
+        /避免.{0,20}(上网|联网|web[_ -]?search|搜索网页)/u
+    ];
+    return chinesePatterns.some((pattern) => pattern.test(originalText));
+}
 function normalizeList(source, fallback) {
     if (!source || source.length === 0) {
         return fallback;

package/dist/router/virtual-router/engine/antigravity/alias-lease.js

@@ -233,11 +233,11 @@ export function recordAntigravitySessionLease(options) {
         return;
     }
     // Bind sessionKey → alias runtimeKey so subsequent routing will prefer this alias.
-    options.sessionAliasStore.set(scopedSessionKey, runtimeKeyBase);
+    options.sessionAliasStore.set(scopedSessionKey, runtimeKey);
     try {
         options.debug?.log?.('[virtual-router][antigravity-session-binding] commit', {
             sessionKey: scopedSessionKey,
-            runtimeKey: runtimeKeyBase,
+            runtimeKey,
             prev: existing?.sessionKey ?? null
         });
     }

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

@@ -0,0 +1,34 @@
+/**
+ * Cooldown Manager Module
+ *
+ * Manages provider cooldown TTLs and health snapshot persistence.
+ */
+import type { VirtualRouterHealthSnapshot, VirtualRouterHealthStore, ProviderHealthConfig } from '../types.js';
+export declare class CooldownManager {
+    private providerCooldowns;
+    private healthStore?;
+    private healthConfig;
+    private quotaView?;
+    constructor(deps?: {
+        healthStore?: VirtualRouterHealthStore;
+        healthConfig?: ProviderHealthConfig | null;
+        quotaView?: (providerKey: string) => {
+            selectionPenalty?: number;
+        } | undefined;
+    });
+    updateDeps(deps: {
+        healthStore?: VirtualRouterHealthStore | null;
+        healthConfig?: ProviderHealthConfig | null;
+        quotaView?: (providerKey: string) => {
+            selectionPenalty?: number;
+        } | undefined | null;
+    }): void;
+    markProviderCooldown(providerKey: string, cooldownMs: number | undefined): void;
+    clearProviderCooldown(providerKey: string): void;
+    isProviderCoolingDown(providerKey: string): boolean;
+    restoreHealthFromStore(): void;
+    buildHealthSnapshot(): VirtualRouterHealthSnapshot;
+    persistHealthSnapshot(): void;
+    clearAllCooldowns(): void;
+    getCooldownMap(): Map<string, number>;
+}

package/dist/router/virtual-router/engine/cooldown-manager.js

@@ -0,0 +1,118 @@
+/**
+ * Cooldown Manager Module
+ *
+ * Manages provider cooldown TTLs and health snapshot persistence.
+ */
+export class CooldownManager {
+    providerCooldowns = new Map();
+    healthStore;
+    healthConfig = null;
+    quotaView;
+    constructor(deps) {
+        if (deps?.healthStore)
+            this.healthStore = deps.healthStore;
+        if (deps?.healthConfig !== undefined)
+            this.healthConfig = deps.healthConfig;
+        if (deps?.quotaView)
+            this.quotaView = deps.quotaView;
+    }
+    updateDeps(deps) {
+        if ('healthStore' in deps)
+            this.healthStore = deps.healthStore ?? undefined;
+        if ('healthConfig' in deps)
+            this.healthConfig = deps.healthConfig ?? null;
+        if ('quotaView' in deps) {
+            const prevQuotaEnabled = Boolean(this.quotaView);
+            this.quotaView = deps.quotaView ?? undefined;
+            const nextQuotaEnabled = Boolean(this.quotaView);
+            // When quotaView is enabled, cooldown must be driven by quotaView only.
+            if (!prevQuotaEnabled && nextQuotaEnabled) {
+                this.providerCooldowns.clear();
+            }
+            else if (prevQuotaEnabled && !nextQuotaEnabled) {
+                this.providerCooldowns.clear();
+                this.restoreHealthFromStore();
+            }
+        }
+    }
+    markProviderCooldown(providerKey, cooldownMs) {
+        if (!providerKey)
+            return;
+        const ttl = typeof cooldownMs === 'number' ? Math.round(cooldownMs) : Number.NaN;
+        if (!Number.isFinite(ttl) || ttl <= 0)
+            return;
+        this.providerCooldowns.set(providerKey, Date.now() + ttl);
+        this.persistHealthSnapshot();
+    }
+    clearProviderCooldown(providerKey) {
+        if (!providerKey)
+            return;
+        if (this.providerCooldowns.delete(providerKey)) {
+            this.persistHealthSnapshot();
+        }
+    }
+    isProviderCoolingDown(providerKey) {
+        if (!providerKey)
+            return false;
+        const expiry = this.providerCooldowns.get(providerKey);
+        if (!expiry)
+            return false;
+        if (Date.now() >= expiry) {
+            this.providerCooldowns.delete(providerKey);
+            return false;
+        }
+        return true;
+    }
+    restoreHealthFromStore() {
+        if (!this.healthStore || typeof this.healthStore.loadInitialSnapshot !== 'function')
+            return;
+        // When quotaView is enabled, health/cooldown must be driven by quotaView only.
+        if (this.quotaView)
+            return;
+        let snapshot = null;
+        try {
+            snapshot = this.healthStore.loadInitialSnapshot();
+        }
+        catch {
+            snapshot = null;
+        }
+        if (!snapshot)
+            return;
+        const now = Date.now();
+        const byKey = new Map();
+        for (const entry of snapshot.cooldowns || []) {
+            if (!entry?.providerKey || !Number.isFinite(entry.cooldownExpiresAt) || entry.cooldownExpiresAt <= now)
+                continue;
+            byKey.set(entry.providerKey, entry);
+            this.providerCooldowns.set(entry.providerKey, entry.cooldownExpiresAt);
+        }
+        // Note: Provider health manager's state is separate; we only restore local cooldowns.
+    }
+    buildHealthSnapshot() {
+        const cooldowns = [];
+        const now = Date.now();
+        for (const [providerKey, expiry] of this.providerCooldowns.entries()) {
+            if (!expiry || expiry <= now)
+                continue;
+            cooldowns.push({ providerKey, cooldownExpiresAt: expiry });
+        }
+        return { providers: [], cooldowns }; // providers part handled by health manager
+    }
+    persistHealthSnapshot() {
+        if (!this.healthStore || typeof this.healthStore.persistSnapshot !== 'function')
+            return;
+        try {
+            const snapshot = this.buildHealthSnapshot();
+            this.healthStore.persistSnapshot(snapshot);
+        }
+        catch {
+            // persistence failure does not affect routing
+        }
+    }
+    clearAllCooldowns() {
+        this.providerCooldowns.clear();
+    }
+    getCooldownMap() {
+        return this.providerCooldowns;
+    }
+}

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

@@ -0,0 +1,28 @@
+/**
+ * Route Analytics Module
+ *
+ * Route statistics and hit tracking extracted from VirtualRouterEngine.
+ */
+import type { RouterMetadataInput } from '../types.js';
+import type { VirtualRouterHitRecord } from '../engine-logging.js';
+export interface RouteLastHit {
+    timestampMs: number;
+    reason?: string;
+    requestTokens?: number;
+    selectionPenalty?: number;
+    stopMessageActive: boolean;
+    stopMessageMode?: 'on' | 'off' | 'auto';
+    stopMessageRemaining?: number;
+}
+export interface RouteStats {
+    hits: number;
+    lastProvider: string;
+    lastHit: RouteLastHit;
+}
+export declare class RouteAnalytics {
+    private routeStats;
+    incrementRouteStat(routeName: string, providerKey: string, hitRecord: VirtualRouterHitRecord): void;
+    getRouteStats(routeName: string): RouteStats | undefined;
+    getAllRouteStats(): Map<string, RouteStats>;
+    extractExcludedProviderKeySet(metadata: RouterMetadataInput | undefined): Set<string>;
+}

package/dist/router/virtual-router/engine/route-analytics.js

@@ -0,0 +1,44 @@
+/**
+ * Route Analytics Module
+ *
+ * Route statistics and hit tracking extracted from VirtualRouterEngine.
+ */
+export class RouteAnalytics {
+    routeStats = new Map();
+    incrementRouteStat(routeName, providerKey, hitRecord) {
+        const nextLastHit = {
+            timestampMs: hitRecord.timestampMs,
+            ...(hitRecord.hitReason ? { reason: hitRecord.hitReason } : {}),
+            ...(typeof hitRecord.requestTokens === 'number' ? { requestTokens: hitRecord.requestTokens } : {}),
+            ...(typeof hitRecord.selectionPenalty === 'number' ? { selectionPenalty: hitRecord.selectionPenalty } : {}),
+            stopMessageActive: hitRecord.stopMessage.active,
+            ...(hitRecord.stopMessage.mode !== 'unset' ? { stopMessageMode: hitRecord.stopMessage.mode } : {}),
+            ...(hitRecord.stopMessage.remaining >= 0 ? { stopMessageRemaining: hitRecord.stopMessage.remaining } : {})
+        };
+        if (!this.routeStats.has(routeName)) {
+            this.routeStats.set(routeName, { hits: 1, lastProvider: providerKey, lastHit: nextLastHit });
+            return;
+        }
+        const stats = this.routeStats.get(routeName);
+        stats.hits += 1;
+        stats.lastProvider = providerKey;
+        stats.lastHit = nextLastHit;
+    }
+    getRouteStats(routeName) {
+        return this.routeStats.get(routeName);
+    }
+    getAllRouteStats() {
+        return this.routeStats;
+    }
+    extractExcludedProviderKeySet(metadata) {
+        if (!metadata)
+            return new Set();
+        const raw = metadata.excludedProviderKeys;
+        if (!Array.isArray(raw) || raw.length === 0)
+            return new Set();
+        const normalized = raw
+            .map((value) => (typeof value === 'string' ? value.trim() : ''))
+            .filter((value) => Boolean(value));
+        return new Set(normalized);
+    }
+}

package/dist/router/virtual-router/engine/routing-pools/index.js

@@ -1,5 +1,6 @@
 import { DEFAULT_ROUTE, VirtualRouterError, VirtualRouterErrorCode } from '../../types.js';
-import { extractExcludedProviderKeySet, extractProviderId } from '../../engine-selection/key-parsing.js';
+import { extractExcludedProviderKeySet, extractKeyAlias, extractKeyIndex, extractProviderId, getProviderModelId } from '../../engine-selection/key-parsing.js';
+import { providerSupportsMultimodalRequest } from '../../engine-selection/multimodal-capability.js';
 import { trySelectFromTier } from '../../engine-selection/tier-selection.js';
 import { resolveInstructionTarget } from '../../engine-selection/instruction-target.js';
 import { filterCandidatesByRoutingState } from '../../engine-selection/routing-state-filter.js';
@@ -49,7 +50,8 @@ 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.quotaView ? true : deps.healthManager.isAvailable(stickyKey)) &&
+            if (stickyProviderMatchesRequestCapabilities(stickyKey, requestedRoute, classification, features, deps.routing, deps.providerRegistry) &&
+                (deps.quotaView ? true : deps.healthManager.isAvailable(stickyKey)) &&
                 !excludedProviderKeys.has(stickyKey) &&
                 !deps.isProviderCoolingDown(stickyKey) &&
                 isAllowedByQuota(stickyKey)) {
@@ -62,7 +64,8 @@ export function selectProviderImpl(requestedRoute, metadata, classification, fea
             }
         }
         if (stickyResolution && stickyResolution.mode === 'filter' && stickyResolution.keys.length > 0) {
-            const liveKeys = stickyResolution.keys.filter((key) => (deps.quotaView ? true : deps.healthManager.isAvailable(key)) &&
+            const liveKeys = stickyResolution.keys.filter((key) => stickyProviderMatchesRequestCapabilities(key, requestedRoute, classification, features, deps.routing, deps.providerRegistry) &&
+                (deps.quotaView ? true : deps.healthManager.isAvailable(key)) &&
                 !excludedProviderKeys.has(key) &&
                 !deps.isProviderCoolingDown(key) &&
                 isAllowedByQuota(key));
@@ -175,9 +178,69 @@ export function selectProviderImpl(requestedRoute, metadata, classification, fea
         allowAliasRotation
     });
 }
+function stickyProviderMatchesRequestCapabilities(providerKey, requestedRoute, classification, features, routing, providerRegistry) {
+    if (!providerKey) {
+        return false;
+    }
+    if (features.hasImageAttachment) {
+        const supportsImageRoute = routeTargetsIncludeProvider(routing, 'multimodal', providerKey) ||
+            routeTargetsIncludeProvider(routing, 'vision', providerKey);
+        if (!supportsImageRoute) {
+            return false;
+        }
+        if (!providerSupportsMultimodalRequest(providerKey, features, providerRegistry)) {
+            return false;
+        }
+    }
+    if (requestRequiresSearchRoute(requestedRoute, classification, features)) {
+        const supportsSearchRoute = routeTargetsIncludeProvider(routing, 'web_search', providerKey) ||
+            routeTargetsIncludeProvider(routing, 'search', providerKey);
+        if (!supportsSearchRoute) {
+            return false;
+        }
+    }
+    return true;
+}
+function requestRequiresSearchRoute(requestedRoute, classification, features) {
+    const normalizedRequestedRoute = normalizeRouteAlias(requestedRoute || DEFAULT_ROUTE);
+    const normalizedClassifiedRoute = normalizeRouteAlias(classification.routeName || DEFAULT_ROUTE);
+    if (normalizedRequestedRoute === 'web_search' || normalizedRequestedRoute === 'search') {
+        return true;
+    }
+    if (normalizedClassifiedRoute === 'web_search' || normalizedClassifiedRoute === 'search') {
+        return true;
+    }
+    const candidates = Array.isArray(classification.candidates) ? classification.candidates : [];
+    if (candidates.some((route) => route === 'web_search' || route === 'search')) {
+        return true;
+    }
+    if (features.hasWebSearchToolDeclared === true) {
+        return true;
+    }
+    return features.metadata?.serverToolRequired === true;
+}
+function routeTargetsIncludeProvider(routing, routeName, providerKey) {
+    const pools = routing[routeName];
+    if (!Array.isArray(pools)) {
+        return false;
+    }
+    for (const pool of pools) {
+        if (!Array.isArray(pool.targets)) {
+            continue;
+        }
+        if (pool.targets.includes(providerKey)) {
+            return true;
+        }
+    }
+    return false;
+}
+function isFinitePositiveNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0;
+}
 function selectFromCandidates(routes, metadata, classification, features, state, deps, options) {
     const allowedProviders = new Set(state.allowedProviders);
     const disabledProviders = new Set(state.disabledProviders);
+    const excludedProviderKeys = extractExcludedProviderKeySet(features.metadata);
     const disabledKeysMap = new Map(Array.from(state.disabledKeys.entries()).map(([provider, keys]) => [
         provider,
         new Set(Array.from(keys).map((k) => (typeof k === 'string' ? k : k + 1)))
@@ -187,6 +250,89 @@ function selectFromCandidates(routes, metadata, classification, features, state,
     const attempted = [];
     const visitedRoutes = new Set();
     const routeQueue = initializeRouteQueue(routes);
+    const healthSnapshotByProviderKey = new Map(deps.healthManager.getSnapshot().map((entry) => [entry.providerKey, entry]));
+    let minRecoverableCooldownMs;
+    const recoverableCooldownHints = [];
+    const recordRecoverableCooldown = (providerKey, waitMsRaw, source) => {
+        const waitMs = Math.max(1, Math.floor(waitMsRaw));
+        if (!isFinitePositiveNumber(waitMs)) {
+            return;
+        }
+        if (!Number.isFinite(minRecoverableCooldownMs) || waitMs < minRecoverableCooldownMs) {
+            minRecoverableCooldownMs = waitMs;
+        }
+        const existing = recoverableCooldownHints.find((item) => item.providerKey === providerKey && item.source === source);
+        if (!existing) {
+            recoverableCooldownHints.push({ providerKey, waitMs, source });
+            return;
+        }
+        if (waitMs < existing.waitMs) {
+            existing.waitMs = waitMs;
+        }
+    };
+    const collectRecoverableCooldownForKey = (providerKey) => {
+        const nowMs = Date.now();
+        if (deps.quotaView) {
+            const entry = deps.quotaView(providerKey);
+            if (!entry) {
+                return;
+            }
+            if (isFinitePositiveNumber(entry.blacklistUntil) && entry.blacklistUntil > nowMs) {
+                return;
+            }
+            if (isFinitePositiveNumber(entry.cooldownUntil) && entry.cooldownUntil > nowMs) {
+                recordRecoverableCooldown(providerKey, entry.cooldownUntil - nowMs, 'quota.cooldown');
+            }
+            return;
+        }
+        if (typeof deps.getProviderCooldownRemainingMs === 'function') {
+            const localCooldownMs = deps.getProviderCooldownRemainingMs(providerKey);
+            if (isFinitePositiveNumber(localCooldownMs)) {
+                recordRecoverableCooldown(providerKey, localCooldownMs, 'router.cooldown');
+            }
+        }
+        const healthState = healthSnapshotByProviderKey.get(providerKey);
+        if (healthState && isFinitePositiveNumber(healthState.cooldownExpiresAt) && healthState.cooldownExpiresAt > nowMs) {
+            recordRecoverableCooldown(providerKey, healthState.cooldownExpiresAt - nowMs, 'health.cooldown');
+        }
+    };
+    const isEligibleTargetForCurrentAttempt = (providerKey) => {
+        if (!providerKey || excludedProviderKeys.has(providerKey)) {
+            return false;
+        }
+        if (options.requiredProviderKeys && options.requiredProviderKeys.size > 0 && !options.requiredProviderKeys.has(providerKey)) {
+            return false;
+        }
+        const providerId = extractProviderId(providerKey);
+        if (!providerId) {
+            return false;
+        }
+        if (allowedProviders.size > 0 && !allowedProviders.has(providerId)) {
+            return false;
+        }
+        if (disabledProviders.has(providerId)) {
+            return false;
+        }
+        const disabledKeys = disabledKeysMap.get(providerId);
+        if (disabledKeys && disabledKeys.size > 0) {
+            const keyAlias = extractKeyAlias(providerKey);
+            const keyIndex = extractKeyIndex(providerKey);
+            if (keyAlias && disabledKeys.has(keyAlias)) {
+                return false;
+            }
+            if (keyIndex !== undefined && disabledKeys.has(keyIndex + 1)) {
+                return false;
+            }
+        }
+        const disabledModelSet = disabledModels.get(providerId);
+        if (disabledModelSet && disabledModelSet.size > 0) {
+            const modelId = getProviderModelId(providerKey, deps.providerRegistry);
+            if (modelId && disabledModelSet.has(modelId)) {
+                return false;
+            }
+        }
+        return true;
+    };
     const estimatedTokens = typeof features.estimatedTokens === 'number' && Number.isFinite(features.estimatedTokens)
         ? Math.max(0, features.estimatedTokens)
         : 0;
@@ -218,8 +364,23 @@ function selectFromCandidates(routes, metadata, classification, features, state,
             if (failureHint) {
                 attempted.push(failureHint);
             }
+            if (Array.isArray(poolTier.targets) && poolTier.targets.length > 0) {
+                for (const providerKey of poolTier.targets) {
+                    if (!isEligibleTargetForCurrentAttempt(providerKey)) {
+                        continue;
+                    }
+                    collectRecoverableCooldownForKey(providerKey);
+                }
+            }
         }
     }
     const requestedRoute = normalizeRouteAlias(classification.routeName || DEFAULT_ROUTE);
-    throw new VirtualRouterError(`All providers unavailable for route ${requestedRoute}`, VirtualRouterErrorCode.PROVIDER_NOT_AVAILABLE, { routeName: requestedRoute, attempted });
+    const details = { routeName: requestedRoute, attempted };
+    if (isFinitePositiveNumber(minRecoverableCooldownMs)) {
+        details.minRecoverableCooldownMs = Math.floor(minRecoverableCooldownMs);
+        details.recoverableCooldownHints = recoverableCooldownHints
+            .sort((a, b) => a.waitMs - b.waitMs)
+            .slice(0, 8);
+    }
+    throw new VirtualRouterError(`All providers unavailable for route ${requestedRoute}`, VirtualRouterErrorCode.PROVIDER_NOT_AVAILABLE, details);
 }

package/dist/router/virtual-router/engine/sticky-session-manager.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Sticky Session Manager Module
+ *
+ * Sticky session and alias lease management extracted from VirtualRouterEngine.
+ */
+export interface AliasLease {
+    sessionKey: string;
+    lastSeenAt: number;
+}
+export declare class StickySessionManager {
+    private aliasQueueStore;
+    private antigravityAliasLeaseStore;
+    private antigravitySessionAliasStore;
+    private antigravityAliasReuseCooldownMs;
+    constructor(aliasReuseCooldownMs?: number);
+    getAliasQueue(alias: string): string[] | undefined;
+    setAliasQueue(alias: string, queue: string[]): void;
+    getAliasLease(alias: string): AliasLease | undefined;
+    setAliasLease(alias: string, lease: AliasLease): void;
+    getSessionAlias(sessionKey: string): string | undefined;
+    setSessionAlias(sessionKey: string, alias: string): void;
+    getAliasReuseCooldownMs(): number;
+    hydrateFromStore(store: Map<string, AliasLease>): void;
+    getAllStores(): {
+        aliasQueueStore: Map<string, string[]>;
+        aliasLeaseStore: Map<string, AliasLease>;
+        sessionAliasStore: Map<string, string>;
+    };
+}

package/dist/router/virtual-router/engine/sticky-session-manager.js

@@ -0,0 +1,55 @@
+/**
+ * Sticky Session Manager Module
+ *
+ * Sticky session and alias lease management extracted from VirtualRouterEngine.
+ */
+export class StickySessionManager {
+    aliasQueueStore = new Map();
+    antigravityAliasLeaseStore = new Map();
+    antigravitySessionAliasStore = new Map();
+    antigravityAliasReuseCooldownMs = 5 * 60_000;
+    constructor(aliasReuseCooldownMs) {
+        if (typeof aliasReuseCooldownMs === 'number' && aliasReuseCooldownMs > 0) {
+            this.antigravityAliasReuseCooldownMs = aliasReuseCooldownMs;
+        }
+    }
+    // Alias queue management
+    getAliasQueue(alias) {
+        return this.aliasQueueStore.get(alias);
+    }
+    setAliasQueue(alias, queue) {
+        this.aliasQueueStore.set(alias, queue);
+    }
+    // Antigravity alias lease
+    getAliasLease(alias) {
+        return this.antigravityAliasLeaseStore.get(alias);
+    }
+    setAliasLease(alias, lease) {
+        this.antigravityAliasLeaseStore.set(alias, lease);
+    }
+    // Session alias mapping
+    getSessionAlias(sessionKey) {
+        return this.antigravitySessionAliasStore.get(sessionKey);
+    }
+    setSessionAlias(sessionKey, alias) {
+        this.antigravitySessionAliasStore.set(sessionKey, alias);
+    }
+    // Cooldown resolution
+    getAliasReuseCooldownMs() {
+        return this.antigravityAliasReuseCooldownMs;
+    }
+    // Hydrate from external store (placeholder for future persistence)
+    hydrateFromStore(store) {
+        for (const [alias, lease] of store.entries()) {
+            this.antigravityAliasLeaseStore.set(alias, lease);
+        }
+    }
+    // Get all stores for persistence
+    getAllStores() {
+        return {
+            aliasQueueStore: this.aliasQueueStore,
+            aliasLeaseStore: this.antigravityAliasLeaseStore,
+            sessionAliasStore: this.antigravitySessionAliasStore
+        };
+    }
+}