@jsonstudio/llms 0.6.2979 → 0.6.3238

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

@@ -0,0 +1,28 @@
+import type { ClassificationResult, RouterMetadataInput, RoutingFeatures } from '../types.js';
+import type { RoutingInstructionState } from '../routing-instructions.js';
+import type { VirtualRouterEngine } from '../engine-legacy.js';
+export declare function selectProvider(engine: VirtualRouterEngine, requestedRoute: string, metadata: RouterMetadataInput, classification: ClassificationResult, features: RoutingFeatures, routingState?: RoutingInstructionState): {
+    providerKey: string;
+    routeUsed: string;
+    pool: string[];
+    poolId?: string;
+};
+export declare function selectFromCandidates(engine: VirtualRouterEngine, routes: string[], metadata: RouterMetadataInput, classification: ClassificationResult, features: RoutingFeatures, state: RoutingInstructionState, requiredProviderKeys?: Set<string>, allowAliasRotation?: boolean): {
+    providerKey: string;
+    routeUsed: string;
+    pool: string[];
+    poolId?: string;
+};
+/**
+ * 在 sticky 模式下，仅在 sticky 池内选择 Provider：
+ * - stickyKeySet 表示已经解析并通过健康检查的 providerKey 集合；
+ * - 不再依赖 routing[*].targets 中是否挂载这些 key，避免「未初始化路由池」导致 sticky 池为空；
+ * - 仍然尊重 allowed/disabledProviders、disabledKeys、disabledModels 以及上下文长度。
+ */
+export declare function selectFromStickyPool(engine: VirtualRouterEngine, stickyKeySet: Set<string>, metadata: RouterMetadataInput, features: RoutingFeatures, state: RoutingInstructionState, allowAliasRotation?: boolean): {
+    providerKey: string;
+    routeUsed: string;
+    pool: string[];
+    poolId?: string;
+} | null;
+export declare function extractExcludedProviderKeySet(engine: VirtualRouterEngine, metadata: RouterMetadataInput | undefined): Set<string>;

package/dist/router/virtual-router/engine-legacy/selection-core.js

@@ -0,0 +1,112 @@
+import { DEFAULT_ROUTE } from '../types.js';
+import { getRoutingInstructionState } from '../engine/routing-state/store.js';
+import { selectProviderImpl } from '../engine/routing-pools/index.js';
+import { extractKeyAlias, extractKeyIndex, extractProviderId, getProviderModelId } from '../engine/provider-key/parse.js';
+export function selectProvider(engine, requestedRoute, metadata, classification, features, routingState) {
+    const activeState = routingState ||
+        getRoutingInstructionState(engine.resolveStickyKey(metadata), engine.routingInstructionState, engine.routingStateStore);
+    return selectProviderImpl(requestedRoute, metadata, classification, features, activeState, {
+        routing: engine.routing,
+        providerRegistry: engine.providerRegistry,
+        healthManager: engine.healthManager,
+        contextAdvisor: engine.contextAdvisor,
+        loadBalancer: engine.loadBalancer,
+        isProviderCoolingDown: (key) => engine.isProviderCoolingDown(key),
+        getProviderCooldownRemainingMs: (key) => engine.getProviderCooldownRemainingMs(key),
+        resolveStickyKey: (m) => engine.resolveStickyKey(m),
+        quotaView: engine.quotaView,
+        aliasQueueStore: engine.stickySessionManager.getAllStores().aliasQueueStore,
+        antigravityAliasLeaseStore: engine.stickySessionManager.getAllStores().aliasLeaseStore,
+        antigravitySessionAliasStore: engine.stickySessionManager.getAllStores().sessionAliasStore,
+        antigravityAliasReuseCooldownMs: engine.stickySessionManager.getAliasReuseCooldownMs()
+    }, { routingState });
+}
+export function selectFromCandidates(engine, routes, metadata, classification, features, state, requiredProviderKeys, allowAliasRotation) {
+    // legacy helper kept for backward compatibility; selection logic moved to engine-selection.ts
+    return selectProviderImpl(engine.normalizeRouteAlias(classification.routeName || DEFAULT_ROUTE), metadata, classification, features, state, {
+        routing: engine.routing,
+        providerRegistry: engine.providerRegistry,
+        healthManager: engine.healthManager,
+        contextAdvisor: engine.contextAdvisor,
+        loadBalancer: engine.loadBalancer,
+        isProviderCoolingDown: (key) => engine.isProviderCoolingDown(key),
+        getProviderCooldownRemainingMs: (key) => engine.getProviderCooldownRemainingMs(key),
+        resolveStickyKey: (m) => engine.resolveStickyKey(m),
+        quotaView: engine.quotaView,
+        aliasQueueStore: engine.stickySessionManager.getAllStores().aliasQueueStore
+    }, { routingState: state });
+}
+/**
+ * 在 sticky 模式下，仅在 sticky 池内选择 Provider：
+ * - stickyKeySet 表示已经解析并通过健康检查的 providerKey 集合；
+ * - 不再依赖 routing[*].targets 中是否挂载这些 key，避免「未初始化路由池」导致 sticky 池为空；
+ * - 仍然尊重 allowed/disabledProviders、disabledKeys、disabledModels 以及上下文长度。
+ */
+export function selectFromStickyPool(engine, stickyKeySet, metadata, features, state, allowAliasRotation) {
+    if (!stickyKeySet || stickyKeySet.size === 0) {
+        return null;
+    }
+    const allowedProviders = new Set(state.allowedProviders);
+    const disabledProviders = new Set(state.disabledProviders);
+    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)))
+    ]));
+    const disabledModels = new Map(Array.from(state.disabledModels.entries()).map(([provider, models]) => [provider, new Set(models)]));
+    // 初始候选集合：sticky 池中的所有 key
+    // In quota routing mode, cooldown is controlled by quotaView only.
+    let candidates = Array.from(stickyKeySet).filter((key) => (engine.quotaView ? true : !engine.isProviderCoolingDown(key)));
+    // 应用 provider 白名单 / 黑名单
+    if (allowedProviders.size > 0) {
+        candidates = candidates.filter((key) => {
+            const providerId = extractProviderId(key);
+            return providerId && allowedProviders.has(providerId);
+        });
+    }
+    if (disabledProviders.size > 0) {
+        candidates = candidates.filter((key) => {
+            const providerId = extractProviderId(key);
+            return providerId && !disabledProviders.has(providerId);
+        });
+    }
+    // 应用 key / model 级别黑名单
+    if (disabledKeysMap.size > 0 || disabledModels.size > 0) {
+        candidates = candidates.filter((key) => {
+            const providerId = extractProviderId(key);
+            if (!providerId) {
+                return true;
+            }
+            const disabledKeys = disabledKeysMap.get(providerId);
+            if (disabledKeys && disabledKeys.size > 0) {
+                const keyAlias = extractKeyAlias(key);
+                const keyIndex = extractKeyIndex(key);
+                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(key, engine.providerRegistry);
+                if (modelId && disabledModelSet.has(modelId)) {
+                    return false;
+                }
+            }
+            return true;
+        });
+    }
+    if (!candidates.length) {
+        return null;
+    }
+    const stickyKey = allowAliasRotation ? undefined : engine.resolveStickyKey(metadata);
+    const estimatedTokens = typeof features.estimatedTokens === 'number' && Number.isFinite(features.estimatedTokens)
+        ? Math.max(0, features.estimatedTokens)
+        : 0;
+    // delegate to selection module
+    return null;
+}
+export function extractExcludedProviderKeySet(engine, metadata) {
+    return engine.routeAnalytics.extractExcludedProviderKeySet(metadata);
+}

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

@@ -0,0 +1,16 @@
+import type { RoutingInstructionState } from '../routing-instructions.js';
+import type { VirtualRouterEngine } from '../engine-legacy.js';
+export declare function resolveSelectionPenalty(engine: VirtualRouterEngine, providerKey: string): number | undefined;
+export declare function resolveInstructionProcessModeForSelection(engine: VirtualRouterEngine, providerKey: string, routingState: RoutingInstructionState): 'chat' | 'passthrough' | undefined;
+export declare function resolveInstructionTarget(engine: VirtualRouterEngine, target: NonNullable<RoutingInstructionState['forcedTarget']>): {
+    mode: 'exact' | 'filter';
+    keys: string[];
+} | null;
+export declare function filterCandidatesByRoutingState(engine: VirtualRouterEngine, routes: string[], state: RoutingInstructionState): string[];
+/**
+ * 在已有候选路由集合上，筛选出真正挂载了 sticky 池内 providerKey 的路由，
+ * 并按 ROUTE_PRIORITY 进行排序；同时显式排除 tools 路由，保证一旦进入
+ * sticky 模式，就不会再命中独立的 tools 池（例如 glm/qwen 工具模型）。
+ * 若候选集合中完全没有挂载 sticky key 的路由，则尝试在 default 路由上兜底。
+ */
+export declare function buildStickyRouteCandidatesFromFiltered(engine: VirtualRouterEngine, filteredCandidates: string[], stickyKeySet: Set<string>): string[];

package/dist/router/virtual-router/engine-legacy/selection-state.js

@@ -0,0 +1,187 @@
+import { DEFAULT_ROUTE } from '../types.js';
+import { extractKeyAlias, extractKeyIndex, extractProviderId, getProviderModelId } from '../engine/provider-key/parse.js';
+import { routeHasTargets, sortByPriority, flattenPoolTargets } from './route-utils.js';
+export function resolveSelectionPenalty(engine, providerKey) {
+    if (!engine.quotaView) {
+        return undefined;
+    }
+    try {
+        const entry = engine.quotaView(providerKey);
+        const raw = entry?.selectionPenalty;
+        if (typeof raw !== 'number' || !Number.isFinite(raw) || raw <= 0) {
+            return undefined;
+        }
+        return Math.floor(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function resolveInstructionProcessModeForSelection(engine, providerKey, routingState) {
+    const candidates = [
+        routingState.forcedTarget,
+        routingState.stickyTarget,
+        routingState.preferTarget
+    ];
+    for (const candidate of candidates) {
+        const processMode = candidate?.processMode;
+        if (!processMode) {
+            continue;
+        }
+        const resolved = resolveInstructionTarget(engine, candidate);
+        if (!resolved) {
+            continue;
+        }
+        if (resolved.keys.includes(providerKey)) {
+            return processMode;
+        }
+    }
+    return undefined;
+}
+export function resolveInstructionTarget(engine, target) {
+    if (!target || !target.provider) {
+        return null;
+    }
+    const providerId = target.provider;
+    const providerKeys = engine.providerRegistry.listProviderKeys(providerId);
+    if (providerKeys.length === 0) {
+        return null;
+    }
+    const alias = typeof target.keyAlias === 'string' ? target.keyAlias.trim() : '';
+    const aliasExplicit = alias.length > 0 && target.pathLength === 3;
+    if (aliasExplicit) {
+        const runtimeKey = engine.providerRegistry.resolveRuntimeKeyByAlias(providerId, alias);
+        if (runtimeKey) {
+            return { mode: 'exact', keys: [runtimeKey] };
+        }
+    }
+    if (typeof target.keyIndex === 'number' && target.keyIndex > 0) {
+        const runtimeKey = engine.providerRegistry.resolveRuntimeKeyByIndex(providerId, target.keyIndex);
+        if (runtimeKey) {
+            return { mode: 'exact', keys: [runtimeKey] };
+        }
+    }
+    if (target.model && target.model.trim()) {
+        const normalizedModel = target.model.trim();
+        const matchingKeys = providerKeys.filter((key) => {
+            const modelId = getProviderModelId(key, engine.providerRegistry);
+            return modelId === normalizedModel;
+        });
+        if (matchingKeys.length > 0) {
+            return { mode: 'filter', keys: matchingKeys };
+        }
+    }
+    if (alias && !aliasExplicit) {
+        const legacyKey = engine.providerRegistry.resolveRuntimeKeyByAlias(providerId, alias);
+        if (legacyKey) {
+            return { mode: 'exact', keys: [legacyKey] };
+        }
+    }
+    return { mode: 'filter', keys: providerKeys };
+}
+export function filterCandidatesByRoutingState(engine, routes, state) {
+    // console.log('[filter] routes:', routes, 'state:', {
+    //   allowed: Array.from(state.allowedProviders),
+    //   disabled: Array.from(state.disabledProviders)
+    // });
+    if (state.allowedProviders.size === 0 &&
+        state.disabledProviders.size === 0 &&
+        state.disabledKeys.size === 0 &&
+        state.disabledModels.size === 0) {
+        return routes;
+    }
+    return routes.filter((routeName) => {
+        const pools = engine.routing[routeName];
+        if (!pools)
+            return false;
+        for (const pool of pools) {
+            if (!Array.isArray(pool.targets) || pool.targets.length === 0) {
+                continue;
+            }
+            for (const providerKey of pool.targets) {
+                const providerId = extractProviderId(providerKey);
+                // console.log('[filter] checking', providerKey, 'id=', providerId);
+                if (!providerId)
+                    continue;
+                if (state.allowedProviders.size > 0 && !state.allowedProviders.has(providerId)) {
+                    // console.log('[filter] dropped by allowed list');
+                    continue;
+                }
+                if (state.disabledProviders.has(providerId)) {
+                    continue;
+                }
+                const disabledKeys = state.disabledKeys.get(providerId);
+                if (disabledKeys && disabledKeys.size > 0) {
+                    const keyAlias = extractKeyAlias(providerKey);
+                    const keyIndex = extractKeyIndex(providerKey);
+                    if (keyAlias && disabledKeys.has(keyAlias)) {
+                        continue;
+                    }
+                    if (keyIndex !== undefined && disabledKeys.has(keyIndex + 1)) {
+                        continue;
+                    }
+                }
+                const disabledModels = state.disabledModels.get(providerId);
+                if (disabledModels && disabledModels.size > 0) {
+                    const modelId = getProviderModelId(providerKey, engine.providerRegistry);
+                    if (modelId && disabledModels.has(modelId)) {
+                        continue;
+                    }
+                }
+                return true;
+            }
+        }
+        return false;
+    });
+}
+/**
+ * 在已有候选路由集合上，筛选出真正挂载了 sticky 池内 providerKey 的路由，
+ * 并按 ROUTE_PRIORITY 进行排序；同时显式排除 tools 路由，保证一旦进入
+ * sticky 模式，就不会再命中独立的 tools 池（例如 glm/qwen 工具模型）。
+ * 若候选集合中完全没有挂载 sticky key 的路由，则尝试在 default 路由上兜底。
+ */
+export function buildStickyRouteCandidatesFromFiltered(engine, filteredCandidates, stickyKeySet) {
+    const routesWithSticky = [];
+    const candidateSet = new Set(filteredCandidates.filter((name) => name && name !== 'tools'));
+    for (const routeName of candidateSet) {
+        const pools = engine.routing[routeName];
+        if (!routeHasTargets(engine, pools)) {
+            continue;
+        }
+        const targets = flattenPoolTargets(engine, pools);
+        if (!targets.some((key) => stickyKeySet.has(key))) {
+            continue;
+        }
+        routesWithSticky.push(routeName);
+    }
+    // 若当前候选路由中没有任何挂载 sticky key 的路由，尝试直接在 default 路由上兜底；
+    // 若 default 也不包含 sticky key，则视为 sticky 配置失效，由调用方回落到非 sticky 逻辑。
+    if (routesWithSticky.length === 0) {
+        const defaultPools = engine.routing[DEFAULT_ROUTE];
+        if (routeHasTargets(engine, defaultPools)) {
+            const targets = flattenPoolTargets(engine, defaultPools);
+            if (targets.some((key) => stickyKeySet.has(key))) {
+                return [DEFAULT_ROUTE];
+            }
+        }
+        return [];
+    }
+    const ordered = sortByPriority(routesWithSticky);
+    const result = [];
+    let hasDefault = false;
+    for (const routeName of ordered) {
+        if (routeName === DEFAULT_ROUTE) {
+            hasDefault = true;
+            continue;
+        }
+        if (!result.includes(routeName)) {
+            result.push(routeName);
+        }
+    }
+    // default 路由若包含 sticky key，则始终放在候选列表最后，用于 sticky 模式兜底。
+    if (hasDefault && !result.includes(DEFAULT_ROUTE)) {
+        result.push(DEFAULT_ROUTE);
+    }
+    return result;
+}
+// Intentionally no extra exports here; keep this module focused on state filtering.

package/dist/router/virtual-router/engine-legacy/state-accessors.d.ts

@@ -0,0 +1,21 @@
+import type { PreCommandStateSnapshot, RouterMetadataInput, StopMessageStateSnapshot } from '../types.js';
+import type { VirtualRouterEngine } from '../engine-legacy.js';
+export declare function getStopMessageState(engine: VirtualRouterEngine, metadata: RouterMetadataInput): StopMessageStateSnapshot | null;
+export declare function getPreCommandState(engine: VirtualRouterEngine, metadata: RouterMetadataInput): PreCommandStateSnapshot | null;
+export declare function getStatus(engine: VirtualRouterEngine): {
+    routes: Record<string, {
+        providers: string[];
+        hits: number;
+        lastUsedProvider?: string;
+        lastHit?: {
+            timestampMs: number;
+            reason?: string;
+            requestTokens?: number;
+            selectionPenalty?: number;
+            stopMessageActive: boolean;
+            stopMessageMode?: "on" | "off" | "auto";
+            stopMessageRemaining?: number;
+        };
+    }>;
+    health: import("../types.js").ProviderHealthState[];
+};

package/dist/router/virtual-router/engine-legacy/state-accessors.js

@@ -0,0 +1,118 @@
+import { resolveStopMessageScope, getRoutingInstructionState, persistRoutingInstructionState } from '../engine/routing-state/store.js';
+import { hasClientInjectScopedFields, stripClientInjectScopedFields } from './helpers.js';
+import { flattenPoolTargets } from './route-utils.js';
+export function getStopMessageState(engine, metadata) {
+    const hasArmedStopState = (candidate) => {
+        if (!candidate) {
+            return false;
+        }
+        const text = typeof candidate.stopMessageText === 'string' ? candidate.stopMessageText.trim() : '';
+        const maxRepeats = typeof candidate.stopMessageMaxRepeats === 'number' && Number.isFinite(candidate.stopMessageMaxRepeats)
+            ? Math.max(1, Math.floor(candidate.stopMessageMaxRepeats))
+            : 0;
+        const mode = typeof candidate.stopMessageStageMode === 'string'
+            ? candidate.stopMessageStageMode.trim().toLowerCase()
+            : '';
+        if (mode === 'off') {
+            return false;
+        }
+        return Boolean(text) && maxRepeats > 0;
+    };
+    const stopMessageScope = resolveStopMessageScope(metadata);
+    if (!stopMessageScope) {
+        const sessionScope = engine.resolveSessionScope(metadata);
+        if (sessionScope) {
+            const legacyState = getRoutingInstructionState(sessionScope, engine.routingInstructionState, engine.routingStateStore);
+            if (hasClientInjectScopedFields(legacyState)) {
+                const cleared = stripClientInjectScopedFields(legacyState);
+                engine.routingInstructionState.set(sessionScope, cleared);
+                persistRoutingInstructionState(sessionScope, cleared, engine.routingStateStore);
+            }
+        }
+        return null;
+    }
+    const effectiveState = getRoutingInstructionState(stopMessageScope, engine.routingInstructionState, engine.routingStateStore);
+    if (!hasArmedStopState(effectiveState)) {
+        return null;
+    }
+    const text = typeof effectiveState.stopMessageText === 'string' ? effectiveState.stopMessageText.trim() : '';
+    const maxRepeats = typeof effectiveState.stopMessageMaxRepeats === 'number' && Number.isFinite(effectiveState.stopMessageMaxRepeats)
+        ? Math.max(1, Math.floor(effectiveState.stopMessageMaxRepeats))
+        : 0;
+    const stageModeRaw = typeof effectiveState.stopMessageStageMode === 'string'
+        ? effectiveState.stopMessageStageMode.trim().toLowerCase()
+        : '';
+    const stageModeNormalized = stageModeRaw === 'on' || stageModeRaw === 'off' || stageModeRaw === 'auto'
+        ? stageModeRaw
+        : undefined;
+    const aiModeRaw = typeof effectiveState.stopMessageAiMode === 'string'
+        ? effectiveState.stopMessageAiMode.trim().toLowerCase()
+        : '';
+    const aiModeNormalized = aiModeRaw === 'on' || aiModeRaw === 'off' ? aiModeRaw : undefined;
+    if (stageModeNormalized === 'off' || !text || maxRepeats <= 0) {
+        return null;
+    }
+    return {
+        ...(text ? { stopMessageText: text } : {}),
+        stopMessageMaxRepeats: maxRepeats,
+        ...(typeof effectiveState.stopMessageSource === 'string' && effectiveState.stopMessageSource.trim()
+            ? { stopMessageSource: effectiveState.stopMessageSource.trim() }
+            : {}),
+        ...(typeof effectiveState.stopMessageUsed === 'number' && Number.isFinite(effectiveState.stopMessageUsed)
+            ? { stopMessageUsed: Math.max(0, Math.floor(effectiveState.stopMessageUsed)) }
+            : {}),
+        ...(typeof effectiveState.stopMessageUpdatedAt === 'number' && Number.isFinite(effectiveState.stopMessageUpdatedAt)
+            ? { stopMessageUpdatedAt: effectiveState.stopMessageUpdatedAt }
+            : {}),
+        ...(typeof effectiveState.stopMessageLastUsedAt === 'number' && Number.isFinite(effectiveState.stopMessageLastUsedAt)
+            ? { stopMessageLastUsedAt: effectiveState.stopMessageLastUsedAt }
+            : {}),
+        ...(stageModeNormalized ? { stopMessageStageMode: stageModeNormalized } : {}),
+        ...(aiModeNormalized ? { stopMessageAiMode: aiModeNormalized } : {}),
+        ...(typeof effectiveState.stopMessageAiSeedPrompt === 'string' && effectiveState.stopMessageAiSeedPrompt.trim()
+            ? { stopMessageAiSeedPrompt: effectiveState.stopMessageAiSeedPrompt.trim() }
+            : {}),
+        ...(Array.isArray(effectiveState.stopMessageAiHistory)
+            ? { stopMessageAiHistory: effectiveState.stopMessageAiHistory }
+            : {})
+    };
+}
+export function getPreCommandState(engine, metadata) {
+    const stopMessageScope = resolveStopMessageScope(metadata);
+    if (!stopMessageScope) {
+        return null;
+    }
+    const effectiveState = getRoutingInstructionState(stopMessageScope, engine.routingInstructionState, engine.routingStateStore);
+    if (!effectiveState) {
+        return null;
+    }
+    const scriptPath = typeof effectiveState.preCommandScriptPath === 'string' ? effectiveState.preCommandScriptPath.trim() : '';
+    if (!scriptPath) {
+        return null;
+    }
+    return {
+        preCommandScriptPath: scriptPath,
+        ...(typeof effectiveState.preCommandSource === 'string' && effectiveState.preCommandSource.trim()
+            ? { preCommandSource: effectiveState.preCommandSource.trim() }
+            : {}),
+        ...(typeof effectiveState.preCommandUpdatedAt === 'number' && Number.isFinite(effectiveState.preCommandUpdatedAt)
+            ? { preCommandUpdatedAt: effectiveState.preCommandUpdatedAt }
+            : {})
+    };
+}
+export function getStatus(engine) {
+    const routes = {};
+    for (const [route, pools] of Object.entries(engine.routing)) {
+        const stats = engine.routeAnalytics.getRouteStats(route);
+        routes[route] = {
+            providers: flattenPoolTargets(engine, pools),
+            hits: stats?.hits ?? 0,
+            lastUsedProvider: stats?.lastProvider,
+            ...(stats?.lastHit ? { lastHit: { ...stats.lastHit } } : {})
+        };
+    }
+    return {
+        routes,
+        health: engine.healthManager.getSnapshot()
+    };
+}

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

@@ -0,0 +1,123 @@
+import { ProviderHealthManager } from './health-manager.js';
+import { ProviderRegistry } from './provider-registry.js';
+import { RouteLoadBalancer } from './load-balancer.js';
+import { RoutingClassifier } from './classifier.js';
+import { ContextAdvisor } from './context-advisor.js';
+import type { ProcessedRequest, StandardizedRequest } from '../../conversion/hub/types/standardized.js';
+import { type RoutingPools, type RoutingDecision, type RoutingDiagnostics, type StopMessageStateSnapshot, type PreCommandStateSnapshot, type RoutePoolTier, type RouterMetadataInput, type RoutingFeatures, type VirtualRouterConfig, type VirtualRouterContextRoutingConfig, type TargetMetadata, type ProviderFailureEvent, type ProviderErrorEvent, type ProviderSuccessEvent, type VirtualRouterHealthStore } from './types.js';
+import type { RoutingInstructionState } from './routing-instructions.js';
+import type { ProviderQuotaView } from './types.js';
+import type { RoutingInstructionStateStoreLike } from './engine/routing-state/store.js';
+import { RouteAnalytics } from './engine/route-analytics.js';
+import { StickySessionManager } from './engine/sticky-session-manager.js';
+import { CooldownManager } from './engine/cooldown-manager.js';
+import { getStatus as getStatusImpl } from './engine-legacy/state-accessors.js';
+export declare class VirtualRouterEngine {
+    routing: RoutingPools;
+    readonly providerRegistry: ProviderRegistry;
+    readonly healthManager: ProviderHealthManager;
+    loadBalancer: RouteLoadBalancer;
+    classifier: RoutingClassifier;
+    readonly contextAdvisor: ContextAdvisor;
+    contextRouting: VirtualRouterContextRoutingConfig | undefined;
+    readonly routeAnalytics: RouteAnalytics;
+    stickySessionManager: StickySessionManager;
+    cooldownManager: CooldownManager;
+    antigravityLeasePersistence: {
+        loadedOnce: boolean;
+        loadedMtimeMs: number | null;
+        flushTimer: ReturnType<typeof setTimeout> | null;
+    };
+    readonly debug: Console;
+    healthConfig: VirtualRouterConfig['health'] | null;
+    readonly statsCenter: import("../../index.js").StatsCenter;
+    webSearchForce: boolean;
+    healthStore?: VirtualRouterHealthStore;
+    routingStateStore: RoutingInstructionStateStoreLike;
+    routingInstructionState: Map<string, RoutingInstructionState>;
+    quotaView?: ProviderQuotaView;
+    /**
+     * Backward-compatible test/debug surface used by existing regression scripts.
+     * Keep this as a read-only view over StickySessionManager storage.
+     */
+    get antigravitySessionAliasStore(): Map<string, string>;
+    constructor(deps?: {
+        healthStore?: VirtualRouterHealthStore;
+        routingStateStore?: RoutingInstructionStateStoreLike;
+        quotaView?: ProviderQuotaView;
+    });
+    updateDeps(deps: {
+        healthStore?: VirtualRouterHealthStore | null;
+        routingStateStore?: RoutingInstructionStateStoreLike | null;
+        quotaView?: ProviderQuotaView | null;
+    }): void;
+    initialize(config: VirtualRouterConfig): void;
+    route(request: StandardizedRequest | ProcessedRequest, metadata: RouterMetadataInput): {
+        target: TargetMetadata;
+        decision: RoutingDecision;
+        diagnostics: RoutingDiagnostics;
+    };
+    getStopMessageState(metadata: RouterMetadataInput): StopMessageStateSnapshot | null;
+    getPreCommandState(metadata: RouterMetadataInput): PreCommandStateSnapshot | null;
+    handleProviderFailure(event: ProviderFailureEvent): void;
+    handleProviderError(event: ProviderErrorEvent): void;
+    handleProviderSuccess(event: ProviderSuccessEvent): void;
+    getStatus(): ReturnType<typeof getStatusImpl>;
+    normalizeRouteAlias(routeName: string | undefined): string;
+    buildRouteCandidates(requestedRoute: string, classificationCandidates: string[] | undefined, features: RoutingFeatures): string[];
+    reorderForInlineVision(routeNames: string[]): string[];
+    reorderForPreferredModel(routeNames: string[], modelId: string): string[];
+    routeSupportsModel(routeName: string, modelId: string): boolean;
+    routeSupportsInlineVision(routeName: string): boolean;
+    sortByPriority(routeNames: string[]): string[];
+    routeWeight(routeName: string): number;
+    routeHasForceFlag(routeName: string): boolean;
+    routeHasTargets(pools?: RoutePoolTier[]): boolean;
+    hasPrimaryPool(pools?: RoutePoolTier[]): boolean;
+    sortRoutePools(pools?: RoutePoolTier[]): RoutePoolTier[];
+    flattenPoolTargets(pools?: RoutePoolTier[]): string[];
+    markProviderCooldown(providerKey: string, cooldownMs: number | undefined): void;
+    clearProviderCooldown(providerKey: string): void;
+    isProviderCoolingDown(providerKey: string): boolean;
+    getProviderCooldownRemainingMs(providerKey: string): number;
+    restoreHealthFromStore(): void;
+    buildHealthSnapshot(): import("./types.js").VirtualRouterHealthSnapshot;
+    persistHealthSnapshot(): void;
+    parseDirectProviderModel(model: string | undefined): {
+        providerId: string;
+        modelId: string;
+    } | null;
+    shouldFallbackDirectModelForMedia(direct: {
+        providerId: string;
+        modelId: string;
+    }, features: RoutingFeatures): boolean;
+    selectProvider(requestedRoute: string, metadata: RouterMetadataInput, classification: any, features: RoutingFeatures, routingState?: RoutingInstructionState): {
+        providerKey: string;
+        routeUsed: string;
+        pool: string[];
+        poolId?: string;
+    };
+    selectFromCandidates(routes: string[], metadata: RouterMetadataInput, classification: any, features: RoutingFeatures, state: RoutingInstructionState, requiredProviderKeys?: Set<string>, allowAliasRotation?: boolean): {
+        providerKey: string;
+        routeUsed: string;
+        pool: string[];
+        poolId?: string;
+    };
+    selectFromStickyPool(stickyKeySet: Set<string>, metadata: RouterMetadataInput, features: RoutingFeatures, state: RoutingInstructionState, allowAliasRotation?: boolean): {
+        providerKey: string;
+        routeUsed: string;
+        pool: string[];
+        poolId?: string;
+    } | null;
+    extractExcludedProviderKeySet(metadata: RouterMetadataInput | undefined): Set<string>;
+    resolveSelectionPenalty(providerKey: string): number | undefined;
+    resolveInstructionProcessModeForSelection(providerKey: string, routingState: RoutingInstructionState): 'chat' | 'passthrough' | undefined;
+    resolveInstructionTarget(target: NonNullable<RoutingInstructionState['forcedTarget']>): {
+        mode: 'exact' | 'filter';
+        keys: string[];
+    } | null;
+    buildStickyRouteCandidatesFromFiltered(filteredCandidates: string[], stickyKeySet: Set<string>): string[];
+    filterCandidatesByRoutingState(routes: string[], state: RoutingInstructionState): string[];
+    resolveStickyKey(metadata: RouterMetadataInput): string | undefined;
+    resolveSessionScope(metadata: RouterMetadataInput): string | undefined;
+}