@jsonstudio/llms 0.6.1164 → 0.6.1354

package/dist/router/virtual-router/engine-selection/instruction-target.js

@@ -0,0 +1,54 @@
+import { getProviderModelId } from './key-parsing.js';
+export function resolveInstructionTarget(target, providerRegistry) {
+    if (!target || !target.provider) {
+        return null;
+    }
+    const providerId = target.provider;
+    const providerKeys = 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 prefix = `${providerId}.${alias}.`;
+        const aliasKeys = providerKeys.filter((key) => key.startsWith(prefix));
+        if (aliasKeys.length > 0) {
+            if (target.model && target.model.trim()) {
+                const normalizedModel = target.model.trim();
+                const matching = aliasKeys.filter((key) => getProviderModelId(key, providerRegistry) === normalizedModel);
+                if (matching.length > 0) {
+                    // Prefer exact to keep sticky pool deterministic when only one key matches.
+                    if (matching.length === 1) {
+                        return { mode: 'exact', keys: [matching[0]] };
+                    }
+                    return { mode: 'filter', keys: matching };
+                }
+            }
+            return { mode: 'filter', keys: aliasKeys };
+        }
+    }
+    if (typeof target.keyIndex === 'number' && target.keyIndex > 0) {
+        const runtimeKey = 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, providerRegistry);
+            return modelId === normalizedModel;
+        });
+        if (matchingKeys.length > 0) {
+            return { mode: 'filter', keys: matchingKeys };
+        }
+    }
+    if (alias && !aliasExplicit) {
+        const legacyKey = providerRegistry.resolveRuntimeKeyByAlias(providerId, alias);
+        if (legacyKey) {
+            return { mode: 'exact', keys: [legacyKey] };
+        }
+    }
+    return { mode: 'filter', keys: providerKeys };
+}

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

@@ -0,0 +1,8 @@
+import type { ProviderRegistry } from '../provider-registry.js';
+import type { RouterMetadataInput } from '../types.js';
+export declare function extractProviderId(providerKey: string): string | null;
+export declare function extractKeyAlias(providerKey: string): string | null;
+export declare function normalizeAliasDescriptor(alias: string): string;
+export declare function extractKeyIndex(providerKey: string): number | undefined;
+export declare function getProviderModelId(providerKey: string, providerRegistry: ProviderRegistry): string | null;
+export declare function extractExcludedProviderKeySet(metadata: RouterMetadataInput | undefined): Set<string>;

package/dist/router/virtual-router/engine-selection/key-parsing.js

@@ -0,0 +1,64 @@
+export function extractProviderId(providerKey) {
+    const firstDot = providerKey.indexOf('.');
+    if (firstDot <= 0)
+        return null;
+    return providerKey.substring(0, firstDot);
+}
+export function extractKeyAlias(providerKey) {
+    // Provider keys are logically: <providerId>.<alias>.<modelId>
+    //
+    // NOTE: modelId can contain dots (e.g. "gpt-5.2"), so we must not assume `split('.')` length === 3.
+    const firstDot = providerKey.indexOf('.');
+    if (firstDot <= 0)
+        return null;
+    const secondDot = providerKey.indexOf('.', firstDot + 1);
+    if (secondDot <= firstDot + 1)
+        return null;
+    const alias = providerKey.substring(firstDot + 1, secondDot);
+    if (!alias)
+        return null;
+    return normalizeAliasDescriptor(alias);
+}
+export function normalizeAliasDescriptor(alias) {
+    if (/^\d+-/.test(alias)) {
+        return alias.replace(/^\d+-/, '');
+    }
+    return alias;
+}
+export function extractKeyIndex(providerKey) {
+    const parts = providerKey.split('.');
+    if (parts.length === 2) {
+        const index = parseInt(parts[1], 10);
+        if (!isNaN(index) && index > 0) {
+            return index;
+        }
+    }
+    return undefined;
+}
+export function getProviderModelId(providerKey, providerRegistry) {
+    const profile = providerRegistry.get(providerKey);
+    if (profile.modelId) {
+        return profile.modelId;
+    }
+    const parts = providerKey.split('.');
+    if (parts.length === 2) {
+        return parts[1] || null;
+    }
+    if (parts.length === 3) {
+        return parts[2] || null;
+    }
+    return null;
+}
+export function 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-selection/route-utils.d.ts

@@ -0,0 +1,12 @@
+import { type RoutePoolTier, type RoutingFeatures } from '../types.js';
+import type { ProviderRegistry } from '../provider-registry.js';
+export declare function sortByPriority(routeNames: string[]): string[];
+export declare function initializeRouteQueue(candidates: string[]): string[];
+export declare function normalizeRouteAlias(routeName: string | undefined): string;
+export declare function routeHasForceFlag(routeName: string, routing: Record<string, RoutePoolTier[]>): boolean;
+export declare function routeHasTargets(pools?: RoutePoolTier[]): boolean;
+export declare function sortRoutePools(pools?: RoutePoolTier[]): RoutePoolTier[];
+export declare function buildRouteCandidates(requestedRoute: string, classificationCandidates: string[] | undefined, features: RoutingFeatures, routing: Record<string, RoutePoolTier[]>, providerRegistry: ProviderRegistry): string[];
+export declare function extendRouteCandidatesForState(candidates: string[], state: {
+    allowedProviders?: Set<string>;
+}, routing: Record<string, RoutePoolTier[]>): string[];

package/dist/router/virtual-router/engine-selection/route-utils.js

@@ -0,0 +1,150 @@
+import { DEFAULT_ROUTE, ROUTE_PRIORITY } from '../types.js';
+export function sortByPriority(routeNames) {
+    return [...routeNames].sort((a, b) => routeWeight(a) - routeWeight(b));
+}
+export function initializeRouteQueue(candidates) {
+    return Array.from(new Set(candidates));
+}
+export function normalizeRouteAlias(routeName) {
+    const base = routeName && routeName.trim() ? routeName.trim() : DEFAULT_ROUTE;
+    return base;
+}
+export function routeHasForceFlag(routeName, routing) {
+    const pools = routing[routeName];
+    if (!Array.isArray(pools)) {
+        return false;
+    }
+    return pools.some((pool) => pool.force);
+}
+export function routeHasTargets(pools) {
+    if (!Array.isArray(pools)) {
+        return false;
+    }
+    return pools.some((pool) => Array.isArray(pool.targets) && pool.targets.length > 0);
+}
+export function sortRoutePools(pools) {
+    if (!Array.isArray(pools)) {
+        return [];
+    }
+    return pools
+        .filter((pool) => Array.isArray(pool.targets) && pool.targets.length > 0)
+        .sort((a, b) => {
+        if (a.backup && !b.backup)
+            return 1;
+        if (!a.backup && b.backup)
+            return -1;
+        if (a.priority !== b.priority) {
+            return b.priority - a.priority;
+        }
+        return a.id.localeCompare(b.id);
+    });
+}
+export function buildRouteCandidates(requestedRoute, classificationCandidates, features, routing, providerRegistry) {
+    const forceVision = routeHasForceFlag('vision', routing);
+    const normalized = normalizeRouteAlias(requestedRoute || DEFAULT_ROUTE);
+    const baseList = [];
+    if (classificationCandidates && classificationCandidates.length) {
+        for (const candidate of classificationCandidates) {
+            baseList.push(normalizeRouteAlias(candidate));
+        }
+    }
+    else if (normalized) {
+        baseList.push(normalized);
+    }
+    if (features.hasImageAttachment && !forceVision) {
+        const visionAwareRoutes = [DEFAULT_ROUTE, 'thinking'];
+        for (const routeName of visionAwareRoutes) {
+            if (routeHasTargets(routing[routeName])) {
+                if (!baseList.includes(routeName)) {
+                    baseList.push(routeName);
+                }
+            }
+        }
+    }
+    let ordered = sortByPriority(baseList);
+    if (features.hasImageAttachment && !forceVision) {
+        ordered = reorderForInlineVision(ordered, routing, providerRegistry);
+    }
+    const deduped = [];
+    for (const routeName of ordered) {
+        if (routeName && !deduped.includes(routeName)) {
+            deduped.push(routeName);
+        }
+    }
+    if (!deduped.includes(DEFAULT_ROUTE)) {
+        deduped.push(DEFAULT_ROUTE);
+    }
+    const filtered = deduped.filter((routeName) => routeHasTargets(routing[routeName]));
+    if (!filtered.includes(DEFAULT_ROUTE) && routeHasTargets(routing[DEFAULT_ROUTE])) {
+        filtered.push(DEFAULT_ROUTE);
+    }
+    return filtered.length ? filtered : [DEFAULT_ROUTE];
+}
+export function extendRouteCandidatesForState(candidates, state, routing) {
+    // When provider allowlists are active (e.g. "<**!glm**>"), routing should not be bounded by
+    // classifier candidates only. Otherwise, a perfectly valid provider that exists in config
+    // (e.g. in a backup/default pool) can become unreachable and cause PROVIDER_NOT_AVAILABLE.
+    //
+    // We keep original ordering, then append all known routes (by priority) as a fallback search space.
+    if (!state.allowedProviders || state.allowedProviders.size === 0) {
+        return candidates;
+    }
+    const allRoutes = sortByPriority(Object.keys(routing).filter((routeName) => routeName && routeHasTargets(routing[routeName])));
+    const expanded = Array.isArray(candidates) ? [...candidates] : [];
+    for (const routeName of allRoutes) {
+        if (!expanded.includes(routeName)) {
+            expanded.push(routeName);
+        }
+    }
+    return expanded;
+}
+function routeWeight(routeName) {
+    const idx = ROUTE_PRIORITY.indexOf(routeName);
+    return idx >= 0 ? idx : ROUTE_PRIORITY.length;
+}
+function reorderForInlineVision(routeNames, routing, providerRegistry) {
+    const unique = Array.from(new Set(routeNames.filter(Boolean)));
+    if (!unique.length) {
+        return unique;
+    }
+    const inlinePreferred = [];
+    const inlineRoutes = [DEFAULT_ROUTE, 'thinking'];
+    for (const routeName of inlineRoutes) {
+        if (routeSupportsInlineVision(routeName, routing, providerRegistry) && !inlinePreferred.includes(routeName)) {
+            inlinePreferred.push(routeName);
+        }
+    }
+    if (!inlinePreferred.length) {
+        return unique;
+    }
+    const remaining = [];
+    for (const routeName of unique) {
+        if (!inlinePreferred.includes(routeName)) {
+            remaining.push(routeName);
+        }
+    }
+    return [...inlinePreferred, ...remaining];
+}
+function routeSupportsInlineVision(routeName, routing, providerRegistry) {
+    const pools = routing[routeName];
+    if (!Array.isArray(pools)) {
+        return false;
+    }
+    for (const pool of pools) {
+        if (!Array.isArray(pool.targets)) {
+            continue;
+        }
+        for (const providerKey of pool.targets) {
+            try {
+                const profile = providerRegistry.get(providerKey);
+                if (profile.providerType === 'responses' || profile.providerType === 'gemini') {
+                    return true;
+                }
+            }
+            catch {
+                // ignore unknown providers when probing capabilities
+            }
+        }
+    }
+    return false;
+}

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

@@ -0,0 +1,4 @@
+import type { RoutePoolTier } from '../types.js';
+import type { RoutingInstructionState } from '../routing-instructions.js';
+import type { ProviderRegistry } from '../provider-registry.js';
+export declare function filterCandidatesByRoutingState(routes: string[], state: RoutingInstructionState, routing: Record<string, RoutePoolTier[]>, providerRegistry: ProviderRegistry): string[];

package/dist/router/virtual-router/engine-selection/routing-state-filter.js

@@ -0,0 +1,50 @@
+import { extractKeyAlias, extractKeyIndex, extractProviderId, getProviderModelId } from './key-parsing.js';
+export function filterCandidatesByRoutingState(routes, state, routing, providerRegistry) {
+    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 = 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);
+                if (!providerId)
+                    continue;
+                if (state.allowedProviders.size > 0 && !state.allowedProviders.has(providerId)) {
+                    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, providerRegistry);
+                    if (modelId && disabledModels.has(modelId)) {
+                        continue;
+                    }
+                }
+                return true;
+            }
+        }
+        return false;
+    });
+}

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

@@ -0,0 +1,39 @@
+import type { RoutePoolTier, RouterMetadataInput, RoutingFeatures, ProviderQuotaView } from '../types.js';
+import type { ContextAdvisor } from '../context-advisor.js';
+import type { RouteLoadBalancer } from '../load-balancer.js';
+import type { ProviderHealthManager } from '../health-manager.js';
+import type { ProviderRegistry } from '../provider-registry.js';
+export type SelectionDeps = {
+    routing: Record<string, RoutePoolTier[]>;
+    providerRegistry: ProviderRegistry;
+    healthManager: ProviderHealthManager;
+    contextAdvisor: ContextAdvisor;
+    loadBalancer: RouteLoadBalancer;
+    isProviderCoolingDown: (providerKey: string) => boolean;
+    resolveStickyKey: (metadata: RouterMetadataInput) => string | undefined;
+    quotaView?: ProviderQuotaView;
+    aliasQueueStore?: Map<string, string[]>;
+};
+export type TrySelectFromTierOptions = {
+    disabledProviders?: Set<string>;
+    disabledKeysMap?: Map<string, Set<string | number>>;
+    allowedProviders?: Set<string>;
+    disabledModels?: Map<string, Set<string>>;
+    requiredProviderKeys?: Set<string>;
+    allowAliasRotation?: boolean;
+};
+export type SelectProviderInput = {
+    routeName: string;
+    tier: RoutePoolTier;
+    stickyKey: string | undefined;
+    estimatedTokens: number;
+    features: RoutingFeatures;
+    deps: SelectionDeps;
+    options: TrySelectFromTierOptions;
+};
+export type SelectionResult = {
+    providerKey: string | null;
+    poolTargets: string[];
+    tierId?: string;
+    failureHint?: string;
+};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,11 @@
+import type { RouterMetadataInput, RoutingFeatures } from '../types.js';
+import type { RoutingInstructionState } from '../routing-instructions.js';
+import type { SelectionDeps } from './selection-deps.js';
+export declare function selectFromStickyPool(stickyKeySet: Set<string>, metadata: RouterMetadataInput, features: RoutingFeatures, state: RoutingInstructionState, deps: SelectionDeps, options: {
+    allowAliasRotation?: boolean;
+}): {
+    providerKey: string;
+    routeUsed: string;
+    pool: string[];
+    poolId?: string;
+} | null;

package/dist/router/virtual-router/engine-selection/sticky-pool.js

@@ -0,0 +1,109 @@
+import { trySelectFromTier } from './tier-selection.js';
+import { extractKeyAlias, extractKeyIndex, extractProviderId, getProviderModelId } from './key-parsing.js';
+export function selectFromStickyPool(stickyKeySet, metadata, features, state, deps, options) {
+    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)]));
+    let candidates = Array.from(stickyKeySet).filter((key) => !deps.isProviderCoolingDown(key));
+    if (!candidates.length && stickyKeySet.size === 1) {
+        candidates = Array.from(stickyKeySet);
+    }
+    const quotaView = deps.quotaView;
+    const now = quotaView ? Date.now() : 0;
+    if (quotaView) {
+        const filtered = candidates.filter((key) => {
+            const entry = quotaView(key);
+            if (!entry) {
+                return true;
+            }
+            if (!entry.inPool) {
+                return false;
+            }
+            if (entry.cooldownUntil && entry.cooldownUntil > now) {
+                return false;
+            }
+            if (entry.blacklistUntil && entry.blacklistUntil > now) {
+                return false;
+            }
+            return true;
+        });
+        if (filtered.length > 0 || candidates.length !== 1) {
+            candidates = filtered;
+        }
+    }
+    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);
+        });
+    }
+    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, deps.providerRegistry);
+                if (modelId && disabledModelSet.has(modelId)) {
+                    return false;
+                }
+            }
+            return true;
+        });
+    }
+    if (!candidates.length) {
+        return null;
+    }
+    const stickyKey = options.allowAliasRotation ? undefined : deps.resolveStickyKey(metadata);
+    const estimatedTokens = typeof features.estimatedTokens === 'number' && Number.isFinite(features.estimatedTokens)
+        ? Math.max(0, features.estimatedTokens)
+        : 0;
+    const tier = {
+        id: 'sticky-primary',
+        targets: candidates,
+        priority: 0
+    };
+    const { providerKey, poolTargets, tierId } = trySelectFromTier('sticky', tier, stickyKey, estimatedTokens, features, deps, {
+        disabledProviders,
+        disabledKeysMap,
+        allowedProviders,
+        disabledModels,
+        requiredProviderKeys: stickyKeySet,
+        allowAliasRotation: options.allowAliasRotation
+    });
+    if (!providerKey) {
+        return null;
+    }
+    return {
+        providerKey,
+        routeUsed: 'sticky',
+        pool: poolTargets,
+        poolId: tierId
+    };
+}

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

@@ -0,0 +1,12 @@
+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;
+    penalties?: Record<string, number>;
+}): {
+    groupId: string;
+    groupCandidates: string[];
+} | null;

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

@@ -0,0 +1,55 @@
+import { extractProviderId, getProviderModelId } from './key-parsing.js';
+function resolvePriorityMeta(orderedTargets, providerRegistry) {
+    // Priority mode semantics (strict group priority + alias-level balancing):
+    // - Targets are interpreted as ordered (providerId, modelId) groups.
+    // - Group base priorities: 100, 90, 80, ... (step=10) by appearance order.
+    // - Within a group (different auth aliases), base scores: 100, 99, 98, ... (step=1).
+    //
+    // Group selection is strict: always use the best group until it is unavailable.
+    // Alias selection is balanced within the chosen group (RR / health-weighted / context-weighted).
+    const meta = new Map();
+    if (!Array.isArray(orderedTargets) || orderedTargets.length === 0) {
+        return meta;
+    }
+    let groupIndex = -1;
+    let aliasOffset = 0;
+    let lastGroupKey = '';
+    for (const key of orderedTargets) {
+        const providerId = extractProviderId(key) ?? '';
+        const modelId = getProviderModelId(key, providerRegistry) ?? '';
+        const groupKey = `${providerId}::${modelId}`;
+        if (groupKey !== lastGroupKey) {
+            groupIndex += 1;
+            aliasOffset = 0;
+            lastGroupKey = groupKey;
+        }
+        const groupBase = 100 - groupIndex * 10;
+        const base = groupBase - aliasOffset;
+        meta.set(key, { groupId: `${providerId}.${modelId}`, groupBase, base });
+        aliasOffset += 1;
+    }
+    return meta;
+}
+export function pickPriorityGroup(opts) {
+    const { candidates, orderedTargets, providerRegistry, healthManager, penalties } = opts;
+    const meta = resolvePriorityMeta(orderedTargets, providerRegistry);
+    let bestGroupId = null;
+    let bestScore = Number.NEGATIVE_INFINITY;
+    for (const key of candidates) {
+        if (!healthManager.isAvailable(key))
+            continue;
+        const m = meta.get(key);
+        if (!m)
+            continue;
+        const penalty = penalties ? Math.max(0, Math.floor(penalties[key] ?? 0)) : 0;
+        const score = m.base - penalty;
+        if (score > bestScore) {
+            bestScore = score;
+            bestGroupId = m.groupId;
+        }
+    }
+    if (!bestGroupId)
+        return null;
+    const groupCandidates = candidates.filter((key) => meta.get(key)?.groupId === bestGroupId);
+    return groupCandidates.length ? { groupId: bestGroupId, groupCandidates } : null;
+}

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

@@ -0,0 +1,22 @@
+import type { ContextAdvisorResult } from '../context-advisor.js';
+import { type ResolvedHealthWeightedConfig } from '../health-weighted.js';
+import type { RoutePoolTier } from '../types.js';
+import type { ResolvedContextWeightedConfig } from '../context-weighted.js';
+import type { SelectionDeps, TrySelectFromTierOptions } from './selection-deps.js';
+export declare function selectProviderKeyFromCandidatePool(opts: {
+    routeName: string;
+    tier: RoutePoolTier;
+    stickyKey: string | undefined;
+    candidates: string[];
+    isSafePool: boolean;
+    deps: SelectionDeps;
+    options: TrySelectFromTierOptions;
+    contextResult: ContextAdvisorResult;
+    warnRatio: number;
+    excludedKeys: Set<string>;
+    isRecoveryAttempt: boolean;
+    now: number;
+    nowForWeights: number;
+    healthWeightedCfg: ResolvedHealthWeightedConfig;
+    contextWeightedCfg: ResolvedContextWeightedConfig;
+}): string | null;