@jsonstudio/llms 0.6.567 → 0.6.568

package/dist/router/virtual-router/engine-health.js

@@ -1,4 +1,105 @@
 const SERIES_COOLDOWN_DETAIL_KEY = 'virtualRouterSeriesCooldown';
+const QUOTA_RECOVERY_DETAIL_KEY = 'virtualRouterQuotaRecovery';
+const QUOTA_DEPLETED_DETAIL_KEY = 'virtualRouterQuotaDepleted';
+function parseDurationToMs(value) {
+    if (!value || typeof value !== 'string') {
+        return null;
+    }
+    const pattern = /(\d+(?:\.\d+)?)(ms|s|m|h)/gi;
+    let totalMs = 0;
+    let matched = false;
+    let match;
+    while ((match = pattern.exec(value)) !== null) {
+        matched = true;
+        const amount = Number.parseFloat(match[1]);
+        if (!Number.isFinite(amount)) {
+            continue;
+        }
+        const unit = match[2].toLowerCase();
+        if (unit === 'ms') {
+            totalMs += amount;
+        }
+        else if (unit === 'h') {
+            totalMs += amount * 3_600_000;
+        }
+        else if (unit === 'm') {
+            totalMs += amount * 60_000;
+        }
+        else if (unit === 's') {
+            totalMs += amount * 1_000;
+        }
+    }
+    if (!matched) {
+        const seconds = Number.parseFloat(value);
+        if (Number.isFinite(seconds)) {
+            totalMs = seconds * 1_000;
+            matched = true;
+        }
+    }
+    if (!matched || totalMs <= 0) {
+        return null;
+    }
+    return Math.round(totalMs);
+}
+function readEnvSchedule(name, fallback) {
+    const raw = (process.env[name] || '').trim();
+    if (!raw) {
+        return fallback;
+    }
+    const parts = raw.split(',').map((token) => token.trim()).filter(Boolean);
+    const parsed = [];
+    for (const part of parts) {
+        const ms = parseDurationToMs(part);
+        if (ms && ms > 0) {
+            parsed.push(ms);
+        }
+    }
+    return parsed.length ? parsed : fallback;
+}
+function readEnvDuration(name, fallbackMs) {
+    const raw = (process.env[name] || '').trim();
+    if (!raw) {
+        return fallbackMs;
+    }
+    const ms = parseDurationToMs(raw);
+    return ms && ms > 0 ? ms : fallbackMs;
+}
+/**
+ * 对没有 quotaResetDelay 的 429 错误，在 VirtualRouter 内部维护一个简单的阶梯退避策略：
+ * - 默认：第 1 次 5 分钟，第 2 次 1 小时，第 3 次 6 小时，第 4 次及以上 24 小时封顶；
+ * - 可通过环境变量 ROUTECODEX_RL_SCHEDULE / RCC_RL_SCHEDULE 调整（例如 "5m,1h,6h,24h"）。
+ *
+ * 这里的“次数”针对 providerKey 计数，并带有简单的时间窗口：若距离上次 429 超过 24 小时，则重置计数。
+ * 该状态仅用于路由决策，不反映在 healthConfig 上，使 Host 与 VirtualRouter 对 429 处理职责清晰分层。
+ */
+const NO_QUOTA_RATE_LIMIT_SCHEDULE_MS = readEnvSchedule('ROUTECODEX_RL_SCHEDULE', [
+    5 * 60_000,
+    60 * 60_000,
+    6 * 60 * 60_000,
+    24 * 60 * 60_000
+]);
+const rateLimitBackoffByProvider = new Map();
+const RATE_LIMIT_RESET_WINDOW_MS = readEnvDuration('ROUTECODEX_RL_RESET_WINDOW', 24 * 60 * 60_000);
+function computeRateLimitCooldownMsForProvider(providerKey, now) {
+    const prev = rateLimitBackoffByProvider.get(providerKey);
+    let nextCount = 1;
+    if (prev) {
+        const elapsed = now - prev.lastAt;
+        if (Number.isFinite(elapsed) && elapsed >= 0 && elapsed < RATE_LIMIT_RESET_WINDOW_MS) {
+            nextCount = prev.count + 1;
+        }
+    }
+    const idx = Math.min(nextCount - 1, NO_QUOTA_RATE_LIMIT_SCHEDULE_MS.length - 1);
+    const ttl = NO_QUOTA_RATE_LIMIT_SCHEDULE_MS[idx];
+    rateLimitBackoffByProvider.set(providerKey, { count: nextCount, lastAt: now });
+    return ttl;
+}
+export function resetRateLimitBackoffForProvider(providerKey) {
+    if (!providerKey) {
+        return;
+    }
+    rateLimitBackoffByProvider.delete(providerKey);
+}
 export function handleProviderFailureImpl(event, healthManager, healthConfig, markProviderCooldown) {
     if (!event || !event.providerKey) {
         return;
@@ -10,9 +111,17 @@ export function handleProviderFailureImpl(event, healthManager, healthConfig, ma
         healthManager.tripProvider(event.providerKey, event.reason, event.cooldownOverrideMs);
     }
     else if (event.reason === 'rate_limit' && event.statusCode === 429) {
-        healthManager.cooldownProvider(event.providerKey, event.reason, event.cooldownOverrideMs);
-        const ttl = event.cooldownOverrideMs ?? healthConfig.cooldownMs;
-        markProviderCooldown(event.providerKey, ttl);
+        // 对非致命的 429 错误：
+        // - 若 ProviderErrorEvent 已携带显式 cooldownOverrideMs（例如来自 quotaResetDelay），则直接使用；
+        // - 否则针对该 providerKey 启用阶梯退避策略（5min → 1h → 6h → 24h），
+        //   在冷却期内从路由池中移除该 alias，避免持续命中上游。
+        const providerKey = event.providerKey;
+        let ttl = event.cooldownOverrideMs;
+        if (!ttl || !Number.isFinite(ttl) || ttl <= 0) {
+            ttl = computeRateLimitCooldownMsForProvider(providerKey, Date.now());
+        }
+        healthManager.cooldownProvider(providerKey, event.reason, ttl);
+        markProviderCooldown(providerKey, ttl);
     }
     else {
         healthManager.recordFailure(event.providerKey, event.reason);
@@ -35,10 +144,20 @@ export function mapProviderErrorImpl(event, healthConfig) {
     const code = event.code?.toUpperCase() ?? 'ERR_UNKNOWN';
     const stage = event.stage?.toLowerCase() ?? 'unknown';
     const recoverable = event.recoverable === true;
+    const providerFamily = runtime.providerFamily &&
+        typeof runtime.providerFamily === 'string'
+        ? runtime.providerFamily
+        : undefined;
+    const providerId = runtime.providerId &&
+        typeof runtime.providerId === 'string'
+        ? runtime.providerId
+        : undefined;
+    const providerTag = (providerFamily || providerId || '').toLowerCase();
+    const isOAuthAuth406 = statusCode === 406 && (providerTag === 'iflow' || providerTag === 'qwen');
     let fatal = !recoverable;
     let reason = deriveReason(code, stage, statusCode);
     let cooldownOverrideMs;
-    if (statusCode === 401 || statusCode === 402 || statusCode === 403 || code.includes('AUTH')) {
+    if (statusCode === 401 || statusCode === 402 || statusCode === 403 || code.includes('AUTH') || isOAuthAuth406) {
         fatal = true;
         cooldownOverrideMs = Math.max(10 * 60_000, healthConfig.fatalCooldownMs ?? 10 * 60_000);
         reason = 'auth';
@@ -117,6 +236,100 @@ export function applySeriesCooldownImpl(event, providerRegistry, healthManager,
         });
     }
 }
+function extractQuotaRecoveryDetail(event) {
+    if (!event || !event.details || typeof event.details !== 'object') {
+        return null;
+    }
+    const raw = event.details[QUOTA_RECOVERY_DETAIL_KEY];
+    if (!raw || typeof raw !== 'object') {
+        return null;
+    }
+    const record = raw;
+    const providerKeyRaw = record.providerKey;
+    if (typeof providerKeyRaw !== 'string' || !providerKeyRaw.trim()) {
+        return null;
+    }
+    const reason = typeof record.reason === 'string' && record.reason.trim()
+        ? record.reason.trim()
+        : undefined;
+    return {
+        providerKey: providerKeyRaw.trim(),
+        reason
+    };
+}
+/**
+ * 处理来自 Host 侧的配额恢复事件：
+ * - 清除指定 providerKey 在健康管理器中的熔断/冷却状态；
+ * - 清理对应的速率退避计数；
+ * - 调用调用方提供的 clearProviderCooldown 回调移除显式 cooldown TTL。
+ *
+ * 返回值表示是否已处理（true=已处理且后续应跳过常规错误映射逻辑）。
+ */
+export function applyQuotaRecoveryImpl(event, healthManager, clearProviderCooldown, debug) {
+    const detail = extractQuotaRecoveryDetail(event);
+    if (!detail) {
+        return false;
+    }
+    const providerKey = detail.providerKey;
+    try {
+        healthManager.recordSuccess(providerKey);
+        resetRateLimitBackoffForProvider(providerKey);
+        clearProviderCooldown(providerKey);
+        debug?.log?.('[virtual-router] quota recovery', {
+            providerKey,
+            reason: detail.reason
+        });
+    }
+    catch {
+        // 恢复失败不得影响主路由流程
+    }
+    return true;
+}
+function extractQuotaDepletedDetail(event) {
+    if (!event || !event.details || typeof event.details !== 'object') {
+        return null;
+    }
+    const raw = event.details[QUOTA_DEPLETED_DETAIL_KEY];
+    if (!raw || typeof raw !== 'object') {
+        return null;
+    }
+    const record = raw;
+    const providerKeyRaw = record.providerKey;
+    if (typeof providerKeyRaw !== 'string' || !providerKeyRaw.trim()) {
+        return null;
+    }
+    const cooldownMs = typeof record.cooldownMs === 'number' && Number.isFinite(record.cooldownMs) && record.cooldownMs > 0
+        ? record.cooldownMs
+        : undefined;
+    const reason = typeof record.reason === 'string' && record.reason.trim()
+        ? record.reason.trim()
+        : undefined;
+    return {
+        providerKey: providerKeyRaw.trim(),
+        cooldownMs,
+        reason
+    };
+}
+export function applyQuotaDepletedImpl(event, healthManager, markProviderCooldown, debug) {
+    const detail = extractQuotaDepletedDetail(event);
+    if (!detail) {
+        return false;
+    }
+    const ttl = detail.cooldownMs;
+    try {
+        healthManager.cooldownProvider(detail.providerKey, 'rate_limit', ttl);
+        markProviderCooldown(detail.providerKey, ttl);
+        debug?.log?.('[virtual-router] quota depleted', {
+            providerKey: detail.providerKey,
+            cooldownMs: ttl,
+            reason: detail.reason
+        });
+    }
+    catch {
+        // ignore failures
+    }
+    return true;
+}
 function resolveSeriesCooldownTargets(detail, event, providerRegistry) {
     const candidates = new Set();
     const push = (key) => {

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

@@ -1,5 +1,6 @@
 import { type ClassificationResult, type RoutingFeatures, type RoutingInstructionMode, type VirtualRouterContextRoutingConfig } from './types.js';
 import { ProviderRegistry } from './provider-registry.js';
+import type { RoutingInstructionState } from './routing-instructions.js';
 type LoggingDeps = {
     providerRegistry: ProviderRegistry;
     contextRouting: VirtualRouterContextRoutingConfig | undefined;
@@ -15,5 +16,5 @@ export declare function describeTargetProvider(providerKey: string, fallbackMode
     resolvedModel?: string;
 };
 export declare function buildHitReason(routeUsed: string, providerKey: string, classification: ClassificationResult, features: RoutingFeatures, mode: RoutingInstructionMode | undefined, deps: LoggingDeps): string;
-export declare function formatVirtualRouterHit(routeName: string, poolId: string | undefined, providerKey: string, modelId?: string, hitReason?: string, stickyScope?: string): string;
+export declare function formatVirtualRouterHit(routeName: string, poolId: string | undefined, providerKey: string, modelId?: string, hitReason?: string, stickyScope?: string, routingState?: RoutingInstructionState): string;
 export {};

package/dist/router/virtual-router/engine-logging.js

@@ -132,7 +132,7 @@ export function buildHitReason(routeUsed, providerKey, classification, features,
     }
     return base;
 }
-export function formatVirtualRouterHit(routeName, poolId, providerKey, modelId, hitReason, stickyScope) {
+export function formatVirtualRouterHit(routeName, poolId, providerKey, modelId, hitReason, stickyScope, routingState) {
     try {
         const now = new Date();
         const hours = String(now.getHours()).padStart(2, '0');
@@ -144,6 +144,7 @@ export function formatVirtualRouterHit(routeName, poolId, providerKey, modelId,
         const timeColor = '\x1b[90m';
         const stickyColor = '\x1b[33m';
         const routeColor = resolveRouteColor(routeName);
+        const stopColor = '\x1b[38;5;214m';
         const prefix = `${prefixColor}[virtual-router-hit]${reset}`;
         const timeLabel = `${timeColor}${timestamp}${reset}`;
         const { providerLabel, resolvedModel } = describeTargetProvider(providerKey, modelId);
@@ -152,7 +153,29 @@ export function formatVirtualRouterHit(routeName, poolId, providerKey, modelId,
         const stickyText = formatStickyScope(stickyScope);
         const stickyLabel = stickyText ? ` ${stickyColor}[sticky:${stickyText}]${reset}` : '';
         const reasonLabel = hitReason ? ` reason=${hitReason}` : '';
-        return `${prefix} ${timeLabel} ${routeColor}${targetLabel}${stickyLabel}${reasonLabel}${reset}`;
+        let stopLabel = '';
+        if (routingState?.stopMessageText && typeof routingState.stopMessageMaxRepeats === 'number') {
+            const text = routingState.stopMessageText;
+            const safeText = text.length > 24 ? `${text.slice(0, 21)}…` : text;
+            const used = typeof routingState.stopMessageUsed === 'number' && Number.isFinite(routingState.stopMessageUsed)
+                ? routingState.stopMessageUsed
+                : 0;
+            const updatedAt = typeof routingState.stopMessageUpdatedAt === 'number' && Number.isFinite(routingState.stopMessageUpdatedAt)
+                ? routingState.stopMessageUpdatedAt
+                : undefined;
+            const lastUsedAt = typeof routingState.stopMessageLastUsedAt === 'number' && Number.isFinite(routingState.stopMessageLastUsedAt)
+                ? routingState.stopMessageLastUsedAt
+                : undefined;
+            const parts = [`"${safeText}"`, `${used}/${Math.floor(routingState.stopMessageMaxRepeats)}`];
+            if (updatedAt) {
+                parts.push(`set=${new Date(updatedAt).toLocaleString(undefined, { hour12: false })}`);
+            }
+            if (lastUsedAt) {
+                parts.push(`last=${new Date(lastUsedAt).toLocaleString(undefined, { hour12: false })}`);
+            }
+            stopLabel = ` ${stopColor}[stopMessage:${parts.join(' ')}]${reset}`;
+        }
+        return `${prefix} ${timeLabel} ${routeColor}${targetLabel}${stickyLabel}${reasonLabel}${stopLabel}${reset}`;
     }
     catch {
         const now = new Date();
@@ -160,6 +183,15 @@ export function formatVirtualRouterHit(routeName, poolId, providerKey, modelId,
         const routeLabel = poolId ? `${routeName}/${poolId}` : routeName;
         const stickyText = formatStickyScope(stickyScope);
         const stickyLabel = stickyText ? ` [sticky:${stickyText}]` : '';
-        return `[virtual-router-hit] ${timestamp} ${routeLabel} -> ${providerKey}${modelId ? '.' + modelId : ''}${stickyLabel}${hitReason ? ` reason=${hitReason}` : ''}`;
+        let stopLabel = '';
+        if (routingState?.stopMessageText && typeof routingState.stopMessageMaxRepeats === 'number') {
+            const text = routingState.stopMessageText;
+            const safeText = text.length > 24 ? `${text.slice(0, 21)}…` : text;
+            const used = typeof routingState.stopMessageUsed === 'number' && Number.isFinite(routingState.stopMessageUsed)
+                ? routingState.stopMessageUsed
+                : 0;
+            stopLabel = ` [stopMessage:"${safeText}" ${used}/${Math.floor(routingState.stopMessageMaxRepeats)}]`;
+        }
+        return `[virtual-router-hit] ${timestamp} ${routeLabel} -> ${providerKey}${modelId ? '.' + modelId : ''}${stickyLabel}${hitReason ? ` reason=${hitReason}` : ''}${stopLabel}`;
     }
 }

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

@@ -1,5 +1,10 @@
-import { type RoutingDecision, type RoutingDiagnostics, type RouterMetadataInput, type VirtualRouterConfig, type TargetMetadata, type ProviderFailureEvent, type ProviderErrorEvent } from './types.js';
+import { type RoutingDecision, type RoutingDiagnostics, type RouterMetadataInput, type VirtualRouterConfig, type TargetMetadata, type ProviderFailureEvent, type ProviderErrorEvent, type VirtualRouterHealthStore } from './types.js';
 import type { ProcessedRequest, StandardizedRequest } from '../../conversion/hub/types/standardized.js';
+import { type RoutingInstructionState } from './routing-instructions.js';
+interface RoutingInstructionStateStore {
+    loadSync(key: string): RoutingInstructionState | null;
+    saveAsync(key: string, state: RoutingInstructionState | null): void;
+}
 export declare class VirtualRouterEngine {
     private routing;
     private readonly providerRegistry;
@@ -14,7 +19,13 @@ export declare class VirtualRouterEngine {
     private healthConfig;
     private readonly statsCenter;
     private webSearchForce;
+    private healthStore?;
+    private routingStateStore;
     private routingInstructionState;
+    constructor(deps?: {
+        healthStore?: VirtualRouterHealthStore;
+        routingStateStore?: RoutingInstructionStateStore;
+    });
     initialize(config: VirtualRouterConfig): void;
     route(request: StandardizedRequest | ProcessedRequest, metadata: RouterMetadataInput): {
         target: TargetMetadata;
@@ -82,5 +93,10 @@ export declare class VirtualRouterEngine {
     private isRoutingStateEmpty;
     private persistRoutingInstructionState;
     private markProviderCooldown;
+    private clearProviderCooldown;
     private isProviderCoolingDown;
+    private restoreHealthFromStore;
+    private buildHealthSnapshot;
+    private persistHealthSnapshot;
 }
+export {};

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

@@ -10,7 +10,7 @@ import { parseRoutingInstructions, applyRoutingInstructions, cleanMessagesFromRo
 import { loadRoutingInstructionStateSync, saveRoutingInstructionStateAsync } from './sticky-session-store.js';
 import { buildHitReason, formatVirtualRouterHit } from './engine-logging.js';
 import { selectProviderImpl } from './engine-selection.js';
-import { applySeriesCooldownImpl, handleProviderFailureImpl, mapProviderErrorImpl } from './engine-health.js';
+import { applyQuotaDepletedImpl, applyQuotaRecoveryImpl, applySeriesCooldownImpl, handleProviderFailureImpl, mapProviderErrorImpl } from './engine-health.js';
 export class VirtualRouterEngine {
     routing = {};
     providerRegistry = new ProviderRegistry();
@@ -26,7 +26,20 @@ export class VirtualRouterEngine {
     statsCenter = getStatsCenter();
     // Derived flags from VirtualRouterConfig/routing used by process / response layers.
     webSearchForce = false;
+    healthStore;
+    routingStateStore = {
+        loadSync: loadRoutingInstructionStateSync,
+        saveAsync: saveRoutingInstructionStateAsync
+    };
     routingInstructionState = new Map();
+    constructor(deps) {
+        if (deps?.healthStore) {
+            this.healthStore = deps.healthStore;
+        }
+        if (deps?.routingStateStore) {
+            this.routingStateStore = deps.routingStateStore;
+        }
+    }
     initialize(config) {
         this.validateConfig(config);
         this.routing = config.routing;
@@ -34,6 +47,8 @@ export class VirtualRouterEngine {
         this.healthManager.configure(config.health);
         this.healthConfig = config.health ?? null;
         this.healthManager.registerProviders(Object.keys(config.providers));
+        this.providerCooldowns.clear();
+        this.restoreHealthFromStore();
         this.loadBalancer = new RouteLoadBalancer(config.loadBalancing);
         this.classifier = new RoutingClassifier(config.classifier);
         this.contextRouting = config.contextRouting ?? { warnRatio: 0.9, hardLimit: false };
@@ -52,6 +67,15 @@ export class VirtualRouterEngine {
         if (metadataInstructions.length > 0) {
             routingState = applyRoutingInstructions(metadataInstructions, routingState);
         }
+        const disableStickyRoutes = metadata &&
+            typeof metadata === 'object' &&
+            metadata.disableStickyRoutes === true;
+        if (disableStickyRoutes && routingState.stickyTarget) {
+            routingState = {
+                ...routingState,
+                stickyTarget: undefined
+            };
+        }
         const instructions = parseRoutingInstructions(request.messages);
         if (instructions.length > 0) {
             routingState = applyRoutingInstructions(instructions, routingState);
@@ -98,7 +122,7 @@ export class VirtualRouterEngine {
         const hitReason = buildHitReason(selection.routeUsed, selection.providerKey, classification, features, routingMode, { providerRegistry: this.providerRegistry, contextRouting: this.contextRouting });
         const stickyScope = routingMode !== 'none' ? this.resolveSessionScope(metadata) : undefined;
         const routeForLog = routingMode === 'sticky' ? 'sticky' : selection.routeUsed;
-        const formatted = formatVirtualRouterHit(routeForLog, selection.poolId, selection.providerKey, target.modelId || '', hitReason, stickyScope);
+        const formatted = formatVirtualRouterHit(routeForLog, selection.poolId, selection.providerKey, target.modelId || '', hitReason, stickyScope, routingState);
         if (formatted) {
             this.debug?.log?.(formatted);
         }
@@ -132,6 +156,24 @@ export class VirtualRouterEngine {
         handleProviderFailureImpl(event, this.healthManager, this.providerHealthConfig(), (key, ttl) => this.markProviderCooldown(key, ttl));
     }
     handleProviderError(event) {
+        if (this.healthStore && typeof this.healthStore.recordProviderError === 'function') {
+            try {
+                this.healthStore.recordProviderError(event);
+            }
+            catch {
+                // ignore persistence errors
+            }
+        }
+        // 配额恢复事件优先处理：一旦识别到 virtualRouterQuotaRecovery，
+        // 直接清理健康状态/冷却 TTL，避免继续走常规错误映射逻辑。
+        const handledByQuota = applyQuotaRecoveryImpl(event, this.healthManager, (key) => this.clearProviderCooldown(key), this.debug);
+        if (handledByQuota) {
+            return;
+        }
+        const handledByQuotaDepleted = applyQuotaDepletedImpl(event, this.healthManager, (key, ttl) => this.markProviderCooldown(key, ttl), this.debug);
+        if (handledByQuotaDepleted) {
+            return;
+        }
         applySeriesCooldownImpl(event, this.providerRegistry, this.healthManager, (key, ttl) => this.markProviderCooldown(key, ttl), this.debug);
         const derived = mapProviderErrorImpl(event, this.providerHealthConfig());
         if (!derived) {
@@ -262,7 +304,9 @@ export class VirtualRouterEngine {
                 disabledModels: new Map(),
                 stopMessageText: undefined,
                 stopMessageMaxRepeats: undefined,
-                stopMessageUsed: undefined
+                stopMessageUsed: undefined,
+                stopMessageUpdatedAt: undefined,
+                stopMessageLastUsedAt: undefined
             };
         }
         this.routingInstructionState.set(key, initial);
@@ -763,17 +807,28 @@ export class VirtualRouterEngine {
         const noDisabledProviders = state.disabledProviders.size === 0;
         const noDisabledKeys = state.disabledKeys.size === 0;
         const noDisabledModels = state.disabledModels.size === 0;
-        return noForced && noSticky && noAllowed && noDisabledProviders && noDisabledKeys && noDisabledModels;
+        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 &&
+            noAllowed &&
+            noDisabledProviders &&
+            noDisabledKeys &&
+            noDisabledModels &&
+            noStopMessage);
     }
     persistRoutingInstructionState(key, state) {
         if (!key || (!key.startsWith('session:') && !key.startsWith('conversation:'))) {
             return;
         }
         if (this.isRoutingStateEmpty(state)) {
-            saveRoutingInstructionStateAsync(key, null);
+            this.routingStateStore.saveAsync(key, null);
             return;
         }
-        saveRoutingInstructionStateAsync(key, state);
+        this.routingStateStore.saveAsync(key, state);
     }
     markProviderCooldown(providerKey, cooldownMs) {
         if (!providerKey) {
@@ -784,6 +839,15 @@ export class VirtualRouterEngine {
             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) {
@@ -799,4 +863,88 @@ export class VirtualRouterEngine {
         }
         return true;
     }
+    restoreHealthFromStore() {
+        if (!this.healthStore || typeof this.healthStore.loadInitialSnapshot !== 'function') {
+            return;
+        }
+        let snapshot = null;
+        try {
+            snapshot = this.healthStore.loadInitialSnapshot();
+        }
+        catch {
+            snapshot = null;
+        }
+        if (!snapshot) {
+            return;
+        }
+        const now = Date.now();
+        const providerKeys = new Set();
+        for (const pools of Object.values(this.routing)) {
+            for (const pool of pools) {
+                for (const key of pool.targets) {
+                    if (typeof key === 'string' && key) {
+                        providerKeys.add(key);
+                    }
+                }
+            }
+        }
+        const byKey = new Map();
+        for (const entry of snapshot.cooldowns || []) {
+            if (!entry || !entry.providerKey) {
+                continue;
+            }
+            if (!providerKeys.has(entry.providerKey)) {
+                continue;
+            }
+            if (!Number.isFinite(entry.cooldownExpiresAt) || entry.cooldownExpiresAt <= now) {
+                continue;
+            }
+            byKey.set(entry.providerKey, entry);
+            this.providerCooldowns.set(entry.providerKey, entry.cooldownExpiresAt);
+        }
+        for (const state of snapshot.providers || []) {
+            if (!state || !state.providerKey) {
+                continue;
+            }
+            if (!providerKeys.has(state.providerKey)) {
+                continue;
+            }
+            if (state.cooldownExpiresAt && state.cooldownExpiresAt > now) {
+                const ttl = state.cooldownExpiresAt - now;
+                if (ttl > 0) {
+                    this.healthManager.tripProvider(state.providerKey, state.reason, ttl);
+                    if (!byKey.has(state.providerKey)) {
+                        this.providerCooldowns.set(state.providerKey, state.cooldownExpiresAt);
+                    }
+                }
+            }
+        }
+    }
+    buildHealthSnapshot() {
+        const providers = this.healthManager.getSnapshot();
+        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 };
+    }
+    persistHealthSnapshot() {
+        if (!this.healthStore || typeof this.healthStore.persistSnapshot !== 'function') {
+            return;
+        }
+        try {
+            const snapshot = this.buildHealthSnapshot();
+            this.healthStore.persistSnapshot(snapshot);
+        }
+        catch {
+            // 持久化失败不影响路由主流程
+        }
+    }
 }

package/dist/router/virtual-router/routing-instructions.d.ts

@@ -31,6 +31,8 @@ export interface RoutingInstructionState {
     stopMessageText?: string;
     stopMessageMaxRepeats?: number;
     stopMessageUsed?: number;
+    stopMessageUpdatedAt?: number;
+    stopMessageLastUsedAt?: number;
 }
 export declare function parseRoutingInstructions(messages: StandardizedMessage[]): RoutingInstruction[];
 export declare function applyRoutingInstructions(instructions: RoutingInstruction[], currentState: RoutingInstructionState): RoutingInstructionState;

package/dist/router/virtual-router/routing-instructions.js

@@ -275,7 +275,9 @@ export function applyRoutingInstructions(instructions, currentState) {
         disabledModels: new Map(Array.from(currentState.disabledModels.entries()).map(([k, v]) => [k, new Set(v)])),
         stopMessageText: currentState.stopMessageText,
         stopMessageMaxRepeats: currentState.stopMessageMaxRepeats,
-        stopMessageUsed: currentState.stopMessageUsed
+        stopMessageUsed: currentState.stopMessageUsed,
+        stopMessageUpdatedAt: currentState.stopMessageUpdatedAt,
+        stopMessageLastUsedAt: currentState.stopMessageLastUsedAt
     };
     let allowReset = false;
     let disableReset = false;
@@ -399,6 +401,8 @@ export function applyRoutingInstructions(instructions, currentState) {
                     newState.stopMessageText = text;
                     newState.stopMessageMaxRepeats = maxRepeats;
                     newState.stopMessageUsed = 0;
+                    newState.stopMessageUpdatedAt = Date.now();
+                    newState.stopMessageLastUsedAt = undefined;
                 }
                 break;
             }
@@ -406,6 +410,8 @@ export function applyRoutingInstructions(instructions, currentState) {
                 newState.stopMessageText = undefined;
                 newState.stopMessageMaxRepeats = undefined;
                 newState.stopMessageUsed = undefined;
+                newState.stopMessageUpdatedAt = undefined;
+                newState.stopMessageLastUsedAt = undefined;
                 break;
         }
     }
@@ -455,6 +461,12 @@ export function serializeRoutingInstructionState(state) {
             : {}),
         ...(typeof state.stopMessageUsed === 'number' && Number.isFinite(state.stopMessageUsed)
             ? { stopMessageUsed: state.stopMessageUsed }
+            : {}),
+        ...(typeof state.stopMessageUpdatedAt === 'number' && Number.isFinite(state.stopMessageUpdatedAt)
+            ? { stopMessageUpdatedAt: state.stopMessageUpdatedAt }
+            : {}),
+        ...(typeof state.stopMessageLastUsedAt === 'number' && Number.isFinite(state.stopMessageLastUsedAt)
+            ? { stopMessageLastUsedAt: state.stopMessageLastUsedAt }
             : {})
     };
 }
@@ -505,5 +517,11 @@ export function deserializeRoutingInstructionState(data) {
     if (typeof data.stopMessageUsed === 'number' && Number.isFinite(data.stopMessageUsed)) {
         state.stopMessageUsed = Math.max(0, Math.floor(data.stopMessageUsed));
     }
+    if (typeof data.stopMessageUpdatedAt === 'number' && Number.isFinite(data.stopMessageUpdatedAt)) {
+        state.stopMessageUpdatedAt = data.stopMessageUpdatedAt;
+    }
+    if (typeof data.stopMessageLastUsedAt === 'number' && Number.isFinite(data.stopMessageLastUsedAt)) {
+        state.stopMessageLastUsedAt = data.stopMessageLastUsedAt;
+    }
     return state;
 }