@jsonstudio/llms 0.6.1643 → 0.6.1739

package/dist/router/virtual-router/engine/provider-key/parse.d.ts

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

package/dist/router/virtual-router/engine/provider-key/parse.js

@@ -0,0 +1,43 @@
+export function extractProviderId(providerKey) {
+    const firstDot = providerKey.indexOf('.');
+    if (firstDot <= 0)
+        return null;
+    return providerKey.substring(0, firstDot);
+}
+export function normalizeAliasDescriptor(alias) {
+    if (/^\d+-/.test(alias)) {
+        return alias.replace(/^\d+-/, '');
+    }
+    return alias;
+}
+export function extractKeyAlias(providerKey) {
+    const parts = providerKey.split('.');
+    if (parts.length === 3) {
+        return normalizeAliasDescriptor(parts[1]);
+    }
+    return null;
+}
+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;
+}

package/dist/router/virtual-router/engine/routing-pools/index.d.ts

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

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

@@ -0,0 +1,225 @@
+import { DEFAULT_ROUTE, VirtualRouterError, VirtualRouterErrorCode } from '../../types.js';
+import { extractExcludedProviderKeySet, extractProviderId } from '../../engine-selection/key-parsing.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';
+import { selectFromStickyPool as selectFromStickyPoolImpl } from '../../engine-selection/sticky-pool.js';
+export { selectDirectProviderModel } from '../../engine-selection/direct-provider-model.js';
+export { selectFromStickyPool } from '../../engine-selection/sticky-pool.js';
+import { buildRouteCandidates, extendRouteCandidatesForState, initializeRouteQueue, normalizeRouteAlias, routeHasTargets, sortRoutePools } from '../../engine-selection/route-utils.js';
+export function selectProviderImpl(requestedRoute, metadata, classification, features, activeState, deps, options = {}) {
+    const state = options.routingState ?? activeState;
+    const quotaView = deps.quotaView;
+    const quotaNow = quotaView ? Date.now() : 0;
+    const isAllowedByQuota = (key) => {
+        if (!quotaView) {
+            return true;
+        }
+        const entry = quotaView(key);
+        if (!entry) {
+            return true;
+        }
+        if (!entry.inPool) {
+            return false;
+        }
+        if (entry.cooldownUntil && entry.cooldownUntil > quotaNow) {
+            return false;
+        }
+        if (entry.blacklistUntil && entry.blacklistUntil > quotaNow) {
+            return false;
+        }
+        return true;
+    };
+    const excludedProviderKeys = extractExcludedProviderKeySet(features.metadata);
+    const forcedResolution = state.forcedTarget ? resolveInstructionTarget(state.forcedTarget, deps.providerRegistry) : null;
+    if (forcedResolution && forcedResolution.mode === 'exact') {
+        const forcedKey = forcedResolution.keys[0];
+        if (!excludedProviderKeys.has(forcedKey) && !deps.isProviderCoolingDown(forcedKey) && isAllowedByQuota(forcedKey)) {
+            return {
+                providerKey: forcedKey,
+                routeUsed: requestedRoute,
+                pool: [forcedKey],
+                poolId: 'forced'
+            };
+        }
+    }
+    let stickyResolution = null;
+    let stickyKeySet;
+    if (!forcedResolution && state.stickyTarget) {
+        stickyResolution = resolveInstructionTarget(state.stickyTarget, deps.providerRegistry);
+        if (stickyResolution && stickyResolution.mode === 'exact') {
+            const stickyKey = stickyResolution.keys[0];
+            if ((deps.quotaView ? true : deps.healthManager.isAvailable(stickyKey)) &&
+                !excludedProviderKeys.has(stickyKey) &&
+                !deps.isProviderCoolingDown(stickyKey) &&
+                isAllowedByQuota(stickyKey)) {
+                return {
+                    providerKey: stickyKey,
+                    routeUsed: requestedRoute,
+                    pool: [stickyKey],
+                    poolId: 'sticky'
+                };
+            }
+        }
+        if (stickyResolution && stickyResolution.mode === 'filter' && stickyResolution.keys.length > 0) {
+            const liveKeys = stickyResolution.keys.filter((key) => (deps.quotaView ? true : deps.healthManager.isAvailable(key)) &&
+                !excludedProviderKeys.has(key) &&
+                !deps.isProviderCoolingDown(key) &&
+                isAllowedByQuota(key));
+            if (liveKeys.length > 0) {
+                stickyKeySet = new Set(liveKeys);
+            }
+        }
+    }
+    const allowAliasRotation = Boolean(state.stickyTarget) &&
+        !state.stickyTarget?.keyAlias &&
+        state.stickyTarget?.keyIndex === undefined;
+    if (forcedResolution && forcedResolution.mode === 'filter') {
+        const forcedKeySet = new Set(forcedResolution.keys);
+        if (forcedKeySet.size > 0) {
+            for (const key of Array.from(forcedKeySet)) {
+                if (excludedProviderKeys.has(key) || deps.isProviderCoolingDown(key)) {
+                    forcedKeySet.delete(key);
+                }
+            }
+        }
+        if (forcedKeySet.size > 0) {
+            const candidates = extendRouteCandidatesForState(buildRouteCandidates(requestedRoute, classification.candidates, features, deps.routing, deps.providerRegistry), state, deps.routing);
+            const filteredCandidates = filterCandidatesByRoutingState(candidates, state, deps.routing, deps.providerRegistry);
+            if (filteredCandidates.length === 0) {
+                const allowedProviders = Array.from(state.allowedProviders);
+                const disabledProviders = Array.from(state.disabledProviders);
+                const providersInRouting = new Set();
+                for (const pools of Object.values(deps.routing)) {
+                    if (!Array.isArray(pools))
+                        continue;
+                    for (const pool of pools) {
+                        if (!pool || !Array.isArray(pool.targets))
+                            continue;
+                        for (const key of pool.targets) {
+                            if (typeof key !== 'string' || !key)
+                                continue;
+                            const providerId = extractProviderId(key);
+                            if (providerId) {
+                                providersInRouting.add(providerId);
+                            }
+                        }
+                    }
+                }
+                const missingAllowedProviders = allowedProviders.length > 0 ? allowedProviders.filter((provider) => !providersInRouting.has(provider)) : [];
+                const hint = (() => {
+                    if (missingAllowedProviders.length > 0) {
+                        return `Allowed providers not present in routing pools: ${missingAllowedProviders.join(', ')}`;
+                    }
+                    return 'Routing instructions excluded all route candidates';
+                })();
+                throw new VirtualRouterError(`No available providers after applying routing instructions (${hint}). ` +
+                    `Tip: remove/adjust <**...**> routing instructions (or use <**clear**>), or add providers/models to routing.`, VirtualRouterErrorCode.PROVIDER_NOT_AVAILABLE, {
+                    requestedRoute,
+                    allowedProviders,
+                    disabledProviders,
+                    missingAllowedProviders
+                });
+            }
+            return selectFromCandidates(filteredCandidates, metadata, classification, features, state, deps, {
+                requiredProviderKeys: forcedKeySet,
+                allowAliasRotation
+            });
+        }
+    }
+    if (stickyKeySet && stickyKeySet.size > 0) {
+        const stickySelection = selectFromStickyPoolImpl(stickyKeySet, metadata, features, state, deps, { allowAliasRotation });
+        if (stickySelection) {
+            return stickySelection;
+        }
+    }
+    const candidates = buildRouteCandidates(requestedRoute, classification.candidates, features, deps.routing, deps.providerRegistry);
+    const expandedCandidates = extendRouteCandidatesForState(candidates, state, deps.routing);
+    const filteredCandidates = filterCandidatesByRoutingState(expandedCandidates, state, deps.routing, deps.providerRegistry);
+    if (filteredCandidates.length === 0) {
+        const allowedProviders = Array.from(state.allowedProviders);
+        const disabledProviders = Array.from(state.disabledProviders);
+        const providersInRouting = new Set();
+        for (const pools of Object.values(deps.routing)) {
+            if (!Array.isArray(pools))
+                continue;
+            for (const pool of pools) {
+                if (!pool || !Array.isArray(pool.targets))
+                    continue;
+                for (const key of pool.targets) {
+                    if (typeof key !== 'string' || !key)
+                        continue;
+                    const providerId = extractProviderId(key);
+                    if (providerId) {
+                        providersInRouting.add(providerId);
+                    }
+                }
+            }
+        }
+        const missingAllowedProviders = allowedProviders.length > 0 ? allowedProviders.filter((provider) => !providersInRouting.has(provider)) : [];
+        const hint = (() => {
+            if (missingAllowedProviders.length > 0) {
+                return `Allowed providers not present in routing pools: ${missingAllowedProviders.join(', ')}`;
+            }
+            return 'Routing instructions excluded all route candidates';
+        })();
+        throw new VirtualRouterError(`No available providers after applying routing instructions (${hint}). ` +
+            `Tip: remove/adjust <**...**> routing instructions (or use <**clear**>), or add providers/models to routing.`, VirtualRouterErrorCode.PROVIDER_NOT_AVAILABLE, {
+            requestedRoute,
+            allowedProviders,
+            disabledProviders,
+            missingAllowedProviders
+        });
+    }
+    return selectFromCandidates(filteredCandidates, metadata, classification, features, state, deps, {
+        allowAliasRotation
+    });
+}
+function selectFromCandidates(routes, metadata, classification, features, state, deps, options) {
+    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)]));
+    const stickyKey = options.allowAliasRotation ? undefined : deps.resolveStickyKey(metadata);
+    const attempted = [];
+    const visitedRoutes = new Set();
+    const routeQueue = initializeRouteQueue(routes);
+    const estimatedTokens = typeof features.estimatedTokens === 'number' && Number.isFinite(features.estimatedTokens)
+        ? Math.max(0, features.estimatedTokens)
+        : 0;
+    while (routeQueue.length) {
+        const routeName = routeQueue.shift();
+        if (visitedRoutes.has(routeName)) {
+            continue;
+        }
+        const routePools = deps.routing[routeName];
+        if (!routeHasTargets(routePools)) {
+            visitedRoutes.add(routeName);
+            attempted.push(`${routeName}:empty`);
+            continue;
+        }
+        visitedRoutes.add(routeName);
+        const orderedPools = sortRoutePools(routePools);
+        for (const poolTier of orderedPools) {
+            const { providerKey, poolTargets, tierId, failureHint } = trySelectFromTier(routeName, poolTier, stickyKey, estimatedTokens, features, deps, {
+                disabledProviders,
+                disabledKeysMap,
+                allowedProviders,
+                disabledModels,
+                requiredProviderKeys: options.requiredProviderKeys,
+                allowAliasRotation: options.allowAliasRotation
+            });
+            if (providerKey) {
+                return { providerKey, routeUsed: routeName, pool: poolTargets, poolId: tierId };
+            }
+            if (failureHint) {
+                attempted.push(failureHint);
+            }
+        }
+    }
+    const requestedRoute = normalizeRouteAlias(classification.routeName || DEFAULT_ROUTE);
+    throw new VirtualRouterError(`All providers unavailable for route ${requestedRoute}`, VirtualRouterErrorCode.PROVIDER_NOT_AVAILABLE, { routeName: requestedRoute, attempted });
+}

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

@@ -0,0 +1,3 @@
+import type { RouterMetadataInput } from '../../types.js';
+export declare function resolveSessionScope(metadata: RouterMetadataInput): string | undefined;
+export declare function resolveStickyKey(metadata: RouterMetadataInput): string;

package/dist/router/virtual-router/engine/routing-state/keys.js

@@ -0,0 +1,30 @@
+export function resolveSessionScope(metadata) {
+    const sessionId = typeof metadata.sessionId === 'string' ? metadata.sessionId.trim() : '';
+    if (sessionId) {
+        return `session:${sessionId}`;
+    }
+    const conversationId = typeof metadata.conversationId === 'string' ? metadata.conversationId.trim() : '';
+    if (conversationId) {
+        return `conversation:${conversationId}`;
+    }
+    return undefined;
+}
+export function resolveStickyKey(metadata) {
+    const providerProtocol = metadata.providerProtocol;
+    // For Responses protocol, auto-sticky is request-chain scoped:
+    // - resume/submit: stickyKey = previousRequestId (points to chain root)
+    // - normal call: stickyKey = requestId
+    if (providerProtocol === 'openai-responses') {
+        const resume = metadata.responsesResume;
+        if (resume && typeof resume.previousRequestId === 'string' && resume.previousRequestId.trim()) {
+            return resume.previousRequestId.trim();
+        }
+        return metadata.requestId;
+    }
+    // Other protocols: session/conversation scoped when available.
+    const sessionScope = resolveSessionScope(metadata);
+    if (sessionScope) {
+        return sessionScope;
+    }
+    return metadata.requestId;
+}

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

@@ -0,0 +1,6 @@
+import type { RouterMetadataInput, RoutingInstructionMode } from '../../types.js';
+import type { RoutingInstruction, RoutingInstructionState } from '../../routing-instructions.js';
+export declare function buildMetadataInstructions(metadata: RouterMetadataInput, options?: {
+    forcedProviderKeyField?: string;
+}): RoutingInstruction[];
+export declare function resolveRoutingMode(instructions: RoutingInstruction[], state: RoutingInstructionState): RoutingInstructionMode;

package/dist/router/virtual-router/engine/routing-state/metadata.js

@@ -0,0 +1,132 @@
+export function buildMetadataInstructions(metadata, options) {
+    const instructions = [];
+    const forcedField = options?.forcedProviderKeyField || '__shadowCompareForcedProviderKey';
+    const forcedProviderKeyRaw = metadata[forcedField];
+    const forcedProviderKey = parseMetadataForceProviderKey(forcedProviderKeyRaw);
+    if (forcedProviderKey) {
+        instructions.push({ type: 'force', ...forcedProviderKey });
+    }
+    if (Array.isArray(metadata.disabledProviderKeyAliases)) {
+        for (const entry of metadata.disabledProviderKeyAliases) {
+            const parsed = parseMetadataDisableDescriptor(entry);
+            if (parsed) {
+                instructions.push({ type: 'disable', ...parsed });
+            }
+        }
+    }
+    return instructions;
+}
+export function resolveRoutingMode(instructions, state) {
+    const hasForce = instructions.some((inst) => inst.type === 'force');
+    const hasAllow = instructions.some((inst) => inst.type === 'allow');
+    const hasClear = instructions.some((inst) => inst.type === 'clear');
+    const hasPrefer = instructions.some((inst) => inst.type === 'prefer');
+    if (hasClear) {
+        return 'none';
+    }
+    if (hasAllow || state.allowedProviders.size > 0) {
+        return 'sticky';
+    }
+    if (hasForce || state.forcedTarget) {
+        return 'force';
+    }
+    if (hasPrefer || state.preferTarget) {
+        return 'sticky';
+    }
+    if (state.stickyTarget) {
+        return 'sticky';
+    }
+    return 'none';
+}
+function parseMetadataDisableDescriptor(entry) {
+    if (typeof entry !== 'string') {
+        return null;
+    }
+    const trimmed = entry.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const parts = trimmed.split('.');
+    if (parts.length < 2) {
+        return null;
+    }
+    const provider = parts[0];
+    const alias = parts[1];
+    if (!provider || !alias) {
+        return null;
+    }
+    if (/^\d+$/.test(alias)) {
+        return { provider, keyIndex: Number.parseInt(alias, 10) };
+    }
+    return { provider, keyAlias: alias };
+}
+function parseMetadataForceProviderKey(entry) {
+    if (typeof entry !== 'string') {
+        return null;
+    }
+    const trimmed = entry.trim();
+    if (!trimmed) {
+        return null;
+    }
+    // Accept the bracket notation used in virtual-router-hit logs: provider[alias].model
+    // - provider[].model means provider.model across all aliases
+    const bracketMatch = trimmed.match(/^([a-zA-Z0-9_-]+)\[([a-zA-Z0-9_-]*)\](?:\.(.+))?$/);
+    if (bracketMatch) {
+        const provider = bracketMatch[1]?.trim() || '';
+        const keyAlias = bracketMatch[2]?.trim() || '';
+        const model = typeof bracketMatch[3] === 'string' ? bracketMatch[3].trim() : '';
+        if (!provider) {
+            return null;
+        }
+        if (keyAlias) {
+            return {
+                provider,
+                keyAlias,
+                ...(model ? { model } : {}),
+                pathLength: 3
+            };
+        }
+        if (model) {
+            return {
+                provider,
+                model,
+                pathLength: 2
+            };
+        }
+        return { provider, pathLength: 1 };
+    }
+    // Accept provider.keyAlias.model and provider.model (model may contain dots when keyAlias is explicit).
+    const parts = trimmed.split('.').map((part) => part.trim()).filter(Boolean);
+    if (parts.length === 0) {
+        return null;
+    }
+    const provider = parts[0] || '';
+    if (!provider) {
+        return null;
+    }
+    if (parts.length === 1) {
+        return { provider, pathLength: 1 };
+    }
+    if (parts.length === 2) {
+        const second = parts[1] || '';
+        if (!second) {
+            return null;
+        }
+        if (/^\d+$/.test(second)) {
+            const keyIndex = Number.parseInt(second, 10);
+            return Number.isFinite(keyIndex) && keyIndex > 0 ? { provider, keyIndex, pathLength: 2 } : null;
+        }
+        return { provider, model: second, pathLength: 2 };
+    }
+    const keyAlias = parts[1] || '';
+    const model = parts.slice(2).join('.').trim();
+    if (!keyAlias) {
+        return null;
+    }
+    return {
+        provider,
+        keyAlias,
+        ...(model ? { model } : {}),
+        pathLength: 3
+    };
+}

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

@@ -0,0 +1,11 @@
+import type { RouterMetadataInput } from '../../types.js';
+import type { RoutingInstructionState } from '../../routing-instructions.js';
+type RoutingInstructionStateStoreLike = {
+    loadSync: (key: string) => RoutingInstructionState | null;
+    saveAsync: (key: string, state: RoutingInstructionState | null) => void;
+    saveSync?: (key: string, state: RoutingInstructionState | null) => void;
+};
+export declare function resolveStopMessageScope(metadata: RouterMetadataInput): string | undefined;
+export declare function getRoutingInstructionState(stickyKey: string | undefined, routingInstructionState: Map<string, RoutingInstructionState>, routingStateStore: RoutingInstructionStateStoreLike): RoutingInstructionState;
+export declare function persistRoutingInstructionState(key: string, state: RoutingInstructionState, routingStateStore: RoutingInstructionStateStoreLike): void;
+export {};

package/dist/router/virtual-router/engine/routing-state/store.js

@@ -0,0 +1,107 @@
+import { mergeStopMessageFromPersisted } from '../../stop-message-state-sync.js';
+export function resolveStopMessageScope(metadata) {
+    const sessionId = typeof metadata?.sessionId === 'string' ? String(metadata.sessionId).trim() : '';
+    if (sessionId) {
+        return `session:${sessionId}`;
+    }
+    return undefined;
+}
+export function getRoutingInstructionState(stickyKey, routingInstructionState, routingStateStore) {
+    const key = stickyKey || 'default';
+    const existing = routingInstructionState.get(key);
+    // 对 session:/conversation: 作用域，在每次读取时尝试从磁盘刷新 stopMessage 相关字段，
+    // 确保 servertool（如 stop_message_auto）通过 sticky-session-store 更新的使用次数
+    // 能在 VirtualRouter 日志中实时反映出来。
+    if (existing && (key.startsWith('session:') || key.startsWith('conversation:'))) {
+        try {
+            const persisted = routingStateStore.loadSync(key);
+            const merged = mergeStopMessageFromPersisted(existing, persisted);
+            existing.stopMessageSource = merged.stopMessageSource;
+            existing.stopMessageText = merged.stopMessageText;
+            existing.stopMessageMaxRepeats = merged.stopMessageMaxRepeats;
+            existing.stopMessageUsed = merged.stopMessageUsed;
+            existing.stopMessageUpdatedAt = merged.stopMessageUpdatedAt;
+            existing.stopMessageLastUsedAt = merged.stopMessageLastUsedAt;
+        }
+        catch {
+            // 刷新失败不影响原有内存状态
+        }
+        return existing;
+    }
+    let initial = null;
+    // 仅对 session:/conversation: 作用域的 key 尝试从磁盘恢复持久化状态
+    if (key.startsWith('session:') || key.startsWith('conversation:')) {
+        initial = routingStateStore.loadSync(key);
+    }
+    if (!initial) {
+        initial = {
+            forcedTarget: undefined,
+            stickyTarget: undefined,
+            allowedProviders: new Set(),
+            disabledProviders: new Set(),
+            disabledKeys: new Map(),
+            disabledModels: new Map(),
+            stopMessageSource: undefined,
+            stopMessageText: undefined,
+            stopMessageMaxRepeats: undefined,
+            stopMessageUsed: undefined,
+            stopMessageUpdatedAt: undefined,
+            stopMessageLastUsedAt: undefined
+        };
+    }
+    routingInstructionState.set(key, initial);
+    return initial;
+}
+function isRoutingStateEmpty(state) {
+    if (!state) {
+        return true;
+    }
+    const noForced = !state.forcedTarget;
+    const noSticky = !state.stickyTarget;
+    const noPrefer = !state.preferTarget;
+    const noAllowed = state.allowedProviders.size === 0;
+    const noDisabledProviders = state.disabledProviders.size === 0;
+    const noDisabledKeys = state.disabledKeys.size === 0;
+    const noDisabledModels = state.disabledModels.size === 0;
+    const noStopMessage = (!state.stopMessageText || !state.stopMessageText.trim()) &&
+        (typeof state.stopMessageMaxRepeats !== 'number' || !Number.isFinite(state.stopMessageMaxRepeats)) &&
+        (typeof state.stopMessageUsed !== 'number' || !Number.isFinite(state.stopMessageUsed)) &&
+        (typeof state.stopMessageUpdatedAt !== 'number' || !Number.isFinite(state.stopMessageUpdatedAt)) &&
+        (typeof state.stopMessageLastUsedAt !== 'number' || !Number.isFinite(state.stopMessageLastUsedAt));
+    return (noForced &&
+        noSticky &&
+        noPrefer &&
+        noAllowed &&
+        noDisabledProviders &&
+        noDisabledKeys &&
+        noDisabledModels &&
+        noStopMessage);
+}
+export function persistRoutingInstructionState(key, state, routingStateStore) {
+    if (!key || (!key.startsWith('session:') && !key.startsWith('conversation:'))) {
+        return;
+    }
+    const supportsSync = typeof routingStateStore.saveSync === 'function';
+    const prefersSync = supportsSync &&
+        key.startsWith('session:') &&
+        (Boolean(state.stopMessageText && state.stopMessageText.trim()) ||
+            (typeof state.stopMessageMaxRepeats === 'number' && Number.isFinite(state.stopMessageMaxRepeats)) ||
+            (typeof state.stopMessageUsed === 'number' && Number.isFinite(state.stopMessageUsed)) ||
+            (typeof state.stopMessageUpdatedAt === 'number' && Number.isFinite(state.stopMessageUpdatedAt)) ||
+            (typeof state.stopMessageLastUsedAt === 'number' && Number.isFinite(state.stopMessageLastUsedAt)));
+    if (isRoutingStateEmpty(state)) {
+        if (prefersSync) {
+            routingStateStore.saveSync(key, null);
+        }
+        else {
+            routingStateStore.saveAsync(key, null);
+        }
+        return;
+    }
+    if (prefersSync) {
+        routingStateStore.saveSync(key, state);
+    }
+    else {
+        routingStateStore.saveAsync(key, state);
+    }
+}

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

@@ -1,23 +1 @@
-import { ProviderHealthManager } from './health-manager.js';
-import { ProviderRegistry } from './provider-registry.js';
-import type { ProviderErrorEvent, ProviderFailureEvent, ProviderHealthConfig } from './types.js';
-type DebugLike = {
-    log?: (...args: unknown[]) => void;
-} | Console | undefined;
-export declare function resetRateLimitBackoffForProvider(providerKey: string): void;
-export declare function applyAntigravityRiskPolicyImpl(event: ProviderErrorEvent, providerRegistry: ProviderRegistry, healthManager: ProviderHealthManager, markProviderCooldown: (providerKey: string, cooldownMs: number | undefined) => void, debug?: DebugLike): void;
-export declare function handleProviderFailureImpl(event: ProviderFailureEvent, healthManager: ProviderHealthManager, healthConfig: Required<ProviderHealthConfig>, markProviderCooldown: (providerKey: string, cooldownMs: number | undefined) => void): void;
-export declare function mapProviderErrorImpl(event: ProviderErrorEvent, healthConfig: Required<ProviderHealthConfig>): ProviderFailureEvent | null;
-export declare function applySeriesCooldownImpl(event: ProviderErrorEvent, providerRegistry: ProviderRegistry, healthManager: ProviderHealthManager, markProviderCooldown: (providerKey: string, cooldownMs: number | undefined) => void, debug?: DebugLike): void;
-/**
- * 处理来自 Host 侧的配额恢复事件：
- * - 清除指定 providerKey 在健康管理器中的熔断/冷却状态；
- * - 清理对应的速率退避计数；
- * - 调用调用方提供的 clearProviderCooldown 回调移除显式 cooldown TTL。
- *
- * 返回值表示是否已处理（true=已处理且后续应跳过常规错误映射逻辑）。
- */
-export declare function applyQuotaRecoveryImpl(event: ProviderErrorEvent, healthManager: ProviderHealthManager, clearProviderCooldown: (providerKey: string) => void, debug?: DebugLike): boolean;
-export declare function applyQuotaDepletedImpl(event: ProviderErrorEvent, healthManager: ProviderHealthManager, markProviderCooldown: (providerKey: string, cooldownMs: number | undefined) => void, debug?: DebugLike): boolean;
-export declare function deriveReason(code: string, stage: string, statusCode?: number): string;
-export {};
+export { applyQuotaDepletedImpl, applyQuotaRecoveryImpl, applySeriesCooldownImpl, applyAntigravityRiskPolicyImpl, handleProviderFailureImpl, mapProviderErrorImpl, resetRateLimitBackoffForProvider, deriveReason } from './engine/health/index.js';