@jsonstudio/llms 0.6.467 → 0.6.567

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

@@ -4,14 +4,18 @@ import { RouteLoadBalancer } from './load-balancer.js';
 import { RoutingClassifier } from './classifier.js';
 import { buildRoutingFeatures } from './features.js';
 import { ContextAdvisor } from './context-advisor.js';
-import { DEFAULT_MODEL_CONTEXT_TOKENS, DEFAULT_ROUTE, ROUTE_PRIORITY, VirtualRouterError, VirtualRouterErrorCode } from './types.js';
+import { DEFAULT_ROUTE, ROUTE_PRIORITY, VirtualRouterError, VirtualRouterErrorCode } from './types.js';
 import { getStatsCenter } from '../../telemetry/stats-center.js';
 import { parseRoutingInstructions, applyRoutingInstructions, cleanMessagesFromRoutingInstructions } from './routing-instructions.js';
 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';
 export class VirtualRouterEngine {
     routing = {};
     providerRegistry = new ProviderRegistry();
     healthManager = new ProviderHealthManager();
+    providerCooldowns = new Map();
     loadBalancer = new RouteLoadBalancer();
     classifier = new RoutingClassifier({});
     contextAdvisor = new ContextAdvisor();
@@ -76,7 +80,6 @@ export class VirtualRouterEngine {
             ...(this.webSearchForce ? { forceWebSearch: true } : {}),
             ...(forceVision ? { forceVision: true } : {})
         };
-        this.healthManager.recordSuccess(selection.providerKey);
         this.incrementRouteStat(selection.routeUsed, selection.providerKey);
         try {
             this.statsCenter.recordVirtualRouterHit({
@@ -92,10 +95,10 @@ export class VirtualRouterEngine {
         catch {
             // stats must never break routing
         }
-        const hitReason = this.buildHitReason(selection.routeUsed, selection.providerKey, classification, features, routingMode);
+        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 = this.formatVirtualRouterHit(routeForLog, selection.poolId, selection.providerKey, target.modelId || '', hitReason, stickyScope);
+        const formatted = formatVirtualRouterHit(routeForLog, selection.poolId, selection.providerKey, target.modelId || '', hitReason, stickyScope);
         if (formatted) {
             this.debug?.log?.(formatted);
         }
@@ -126,21 +129,11 @@ export class VirtualRouterEngine {
         };
     }
     handleProviderFailure(event) {
-        if (!event || !event.providerKey) {
-            return;
-        }
-        if (event.affectsHealth === false) {
-            return;
-        }
-        if (event.fatal) {
-            this.healthManager.tripProvider(event.providerKey, event.reason, event.cooldownOverrideMs);
-        }
-        else {
-            this.healthManager.recordFailure(event.providerKey, event.reason);
-        }
+        handleProviderFailureImpl(event, this.healthManager, this.providerHealthConfig(), (key, ttl) => this.markProviderCooldown(key, ttl));
     }
     handleProviderError(event) {
-        const derived = this.mapProviderError(event);
+        applySeriesCooldownImpl(event, this.providerRegistry, this.healthManager, (key, ttl) => this.markProviderCooldown(key, ttl), this.debug);
+        const derived = mapProviderErrorImpl(event, this.providerHealthConfig());
         if (!derived) {
             return;
         }
@@ -205,200 +198,15 @@ export class VirtualRouterEngine {
     }
     selectProvider(requestedRoute, metadata, classification, features, routingState) {
         const activeState = routingState || this.getRoutingInstructionState(this.resolveStickyKey(metadata));
-        const forcedResolution = activeState.forcedTarget
-            ? this.resolveInstructionTarget(activeState.forcedTarget)
-            : null;
-        if (forcedResolution && forcedResolution.mode === 'exact') {
-            const forcedKey = forcedResolution.keys[0];
-            return {
-                providerKey: forcedKey,
-                routeUsed: requestedRoute,
-                pool: [forcedKey],
-                poolId: 'forced'
-            };
-        }
-        // sticky 语义：
-        // - 显式绑定到具体 key（alias/index）时，直接使用该 key；
-        // - provider / model 级别 sticky 解析为一组 providerKey；
-        //   在 sticky 这组 key「可用」之前，不会回落到 default 中的非 sticky provider。
-        let stickyResolution = null;
-        let stickyKeySet;
-        if (!forcedResolution && activeState.stickyTarget) {
-            stickyResolution = this.resolveInstructionTarget(activeState.stickyTarget);
-            if (stickyResolution && stickyResolution.mode === 'exact') {
-                const stickyKey = stickyResolution.keys[0];
-                // 已经被健康管理标记为不可用的 key 不能被 sticky 语法“复活”
-                if (this.healthManager.isAvailable(stickyKey)) {
-                    return {
-                        providerKey: stickyKey,
-                        routeUsed: requestedRoute,
-                        pool: [stickyKey],
-                        poolId: 'sticky'
-                    };
-                }
-            }
-            if (stickyResolution && stickyResolution.mode === 'filter' && stickyResolution.keys.length > 0) {
-                // 仅保留当前仍可用的 key；已被熔断/拉黑的 key 不会被 sticky 语法重新加入池子
-                const liveKeys = stickyResolution.keys.filter((key) => this.healthManager.isAvailable(key));
-                if (liveKeys.length > 0) {
-                    stickyKeySet = new Set(liveKeys);
-                }
-            }
-        }
-        const allowAliasRotation = Boolean(activeState.stickyTarget) &&
-            !activeState.stickyTarget?.keyAlias &&
-            activeState.stickyTarget?.keyIndex === undefined;
-        // force(filter) 优先级高于 sticky：显式 force 视为覆盖 sticky 约束。
-        if (forcedResolution && forcedResolution.mode === 'filter') {
-            const candidates = this.buildRouteCandidates(requestedRoute, classification.candidates, features);
-            const filteredCandidates = this.filterCandidatesByRoutingState(candidates, activeState);
-            if (filteredCandidates.length === 0) {
-                throw new VirtualRouterError('No available providers after applying routing instructions', VirtualRouterErrorCode.PROVIDER_NOT_AVAILABLE, {
-                    requestedRoute,
-                    allowedProviders: Array.from(activeState.allowedProviders),
-                    disabledProviders: Array.from(activeState.disabledProviders)
-                });
-            }
-            const forcedKeySet = new Set(forcedResolution.keys);
-            return this.selectFromCandidates(filteredCandidates, metadata, classification, features, activeState, forcedKeySet, allowAliasRotation);
-        }
-        if (stickyKeySet && stickyKeySet.size > 0) {
-            const stickySelection = this.selectFromStickyPool(stickyKeySet, metadata, features, activeState, allowAliasRotation);
-            if (stickySelection) {
-                return stickySelection;
-            }
-            // sticky 池在本次请求中完全不可用（全部被黑名单/健康状态过滤）：视为 sticky 池暂时失效，
-            // 本次回落到普通路由选择，但保留 stickyTarget，等待后续恢复。
-        }
-        // 无 sticky，或 sticky 池在本次请求中全部不可用（无可用 key）：按原始分类结果执行正常路由选择。
-        const candidates = this.buildRouteCandidates(requestedRoute, classification.candidates, features);
-        const filteredCandidates = this.filterCandidatesByRoutingState(candidates, activeState);
-        if (filteredCandidates.length === 0) {
-            throw new VirtualRouterError('No available providers after applying routing instructions', VirtualRouterErrorCode.PROVIDER_NOT_AVAILABLE, {
-                requestedRoute,
-                allowedProviders: Array.from(activeState.allowedProviders),
-                disabledProviders: Array.from(activeState.disabledProviders)
-            });
-        }
-        return this.selectFromCandidates(filteredCandidates, metadata, classification, features, activeState, undefined, allowAliasRotation);
-    }
-    trySelectFromTier(routeName, tier, stickyKey, estimatedTokens, features, disabledProviders, disabledKeysMap, allowedProviders, disabledModels, requiredProviderKeys, allowAliasRotation) {
-        let targets = Array.isArray(tier.targets) ? tier.targets : [];
-        if (allowedProviders && allowedProviders.size > 0) {
-            targets = targets.filter(key => {
-                const providerId = this.extractProviderId(key);
-                return providerId && allowedProviders.has(providerId);
-            });
-        }
-        if (disabledProviders && disabledProviders.size > 0) {
-            targets = targets.filter((key) => {
-                const providerId = this.extractProviderId(key);
-                return providerId && !disabledProviders.has(providerId);
-            });
-        }
-        if (disabledKeysMap && disabledKeysMap.size > 0) {
-            targets = targets.filter((key) => {
-                const providerId = this.extractProviderId(key);
-                if (!providerId)
-                    return true;
-                const disabledKeys = disabledKeysMap.get(providerId);
-                if (!disabledKeys || disabledKeys.size === 0)
-                    return true;
-                const keyAlias = this.extractKeyAlias(key);
-                const keyIndex = this.extractKeyIndex(key);
-                if (keyAlias && disabledKeys.has(keyAlias)) {
-                    return false;
-                }
-                if (keyIndex !== undefined && disabledKeys.has(keyIndex + 1)) {
-                    return false;
-                }
-                return true;
-            });
-        }
-        if (disabledModels && disabledModels.size > 0) {
-            targets = targets.filter((key) => {
-                const providerId = this.extractProviderId(key);
-                if (!providerId) {
-                    return true;
-                }
-                const disabled = disabledModels.get(providerId);
-                if (!disabled || disabled.size === 0) {
-                    return true;
-                }
-                const modelId = this.getProviderModelId(key);
-                if (!modelId) {
-                    return true;
-                }
-                return !disabled.has(modelId);
-            });
-        }
-        if (requiredProviderKeys && requiredProviderKeys.size > 0) {
-            targets = targets.filter((key) => requiredProviderKeys.has(key));
-        }
-        const serverToolRequired = features.metadata?.serverToolRequired === true;
-        if (serverToolRequired) {
-            const filtered = [];
-            for (const key of targets) {
-                try {
-                    const profile = this.providerRegistry.get(key);
-                    if (!profile.serverToolsDisabled) {
-                        filtered.push(key);
-                    }
-                }
-                catch {
-                    // ignore unknown providers when filtering for servertools
-                }
-            }
-            targets = filtered;
-        }
-        // 当当前请求包含图片且路由为 default/thinking 时，优先在该路由池内选择
-        // Responses/Gemini 类型的 Provider，以便一次完成多模态推理；如果不存在则回退到原始列表。
-        if (features.hasImageAttachment && (routeName === DEFAULT_ROUTE || routeName === 'thinking')) {
-            const prioritized = [];
-            const fallthrough = [];
-            for (const key of targets) {
-                try {
-                    const profile = this.providerRegistry.get(key);
-                    if (profile.providerType === 'responses') {
-                        prioritized.push(key);
-                    }
-                    else if (profile.providerType === 'gemini') {
-                        prioritized.push(key);
-                    }
-                    else {
-                        fallthrough.push(key);
-                    }
-                }
-                catch {
-                    fallthrough.push(key);
-                }
-            }
-            if (prioritized.length) {
-                targets = prioritized;
-            }
-        }
-        if (!targets.length) {
-            return { providerKey: null, poolTargets: [], tierId: tier.id, failureHint: `${routeName}:${tier.id}:empty` };
-        }
-        const contextResult = this.contextAdvisor.classify(targets, estimatedTokens, (key) => this.providerRegistry.get(key));
-        const prioritizedPools = this.buildContextCandidatePools(contextResult);
-        for (const candidatePool of prioritizedPools) {
-            const providerKey = this.loadBalancer.select({
-                routeName: `${routeName}:${tier.id}`,
-                candidates: candidatePool,
-                stickyKey: allowAliasRotation ? undefined : stickyKey,
-                availabilityCheck: (key) => this.healthManager.isAvailable(key)
-            });
-            if (providerKey) {
-                return { providerKey, poolTargets: tier.targets, tierId: tier.id };
-            }
-        }
-        return {
-            providerKey: null,
-            poolTargets: tier.targets,
-            tierId: tier.id,
-            failureHint: this.describeAttempt(routeName, tier.id, contextResult)
-        };
+        return selectProviderImpl(requestedRoute, metadata, classification, features, activeState, {
+            routing: this.routing,
+            providerRegistry: this.providerRegistry,
+            healthManager: this.healthManager,
+            contextAdvisor: this.contextAdvisor,
+            loadBalancer: this.loadBalancer,
+            isProviderCoolingDown: (key) => this.isProviderCoolingDown(key),
+            resolveStickyKey: (m) => this.resolveStickyKey(m)
+        }, { routingState });
     }
     incrementRouteStat(routeName, providerKey) {
         if (!this.routeStats.has(routeName)) {
@@ -412,35 +220,6 @@ export class VirtualRouterEngine {
     providerHealthConfig() {
         return this.healthManager.getConfig();
     }
-    initializeRouteQueue(candidates) {
-        return Array.from(new Set(candidates));
-    }
-    buildContextCandidatePools(result) {
-        const ordered = [];
-        if (result.safe.length) {
-            ordered.push(result.safe);
-            // 如果存在安全候选，直接放弃当前处于警戒阈值的模型
-            return ordered;
-        }
-        if (result.risky.length) {
-            ordered.push(result.risky);
-        }
-        // ratio >= 1 视为上下文溢出，直接标记为不可用
-        return ordered;
-    }
-    describeAttempt(routeName, poolId, result) {
-        const prefix = poolId ? `${routeName}:${poolId}` : routeName;
-        if (result.safe.length > 0) {
-            return `${prefix}:health`;
-        }
-        if (result.risky.length > 0) {
-            return `${prefix}:context_risky`;
-        }
-        if (result.overflow.length > 0) {
-            return `${prefix}:max_context_window`;
-        }
-        return prefix;
-    }
     resolveStickyKey(metadata) {
         const sessionScope = this.resolveSessionScope(metadata);
         if (sessionScope) {
@@ -480,7 +259,10 @@ export class VirtualRouterEngine {
                 allowedProviders: new Set(),
                 disabledProviders: new Set(),
                 disabledKeys: new Map(),
-                disabledModels: new Map()
+                disabledModels: new Map(),
+                stopMessageText: undefined,
+                stopMessageMaxRepeats: undefined,
+                stopMessageUsed: undefined
             };
         }
         this.routingInstructionState.set(key, initial);
@@ -635,45 +417,16 @@ export class VirtualRouterEngine {
         });
     }
     selectFromCandidates(routes, metadata, classification, features, state, requiredProviderKeys, allowAliasRotation) {
-        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 = allowAliasRotation ? undefined : this.resolveStickyKey(metadata);
-        const attempted = [];
-        const visitedRoutes = new Set();
-        const routeQueue = this.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 = this.routing[routeName];
-            if (!this.routeHasTargets(routePools)) {
-                visitedRoutes.add(routeName);
-                attempted.push(`${routeName}:empty`);
-                continue;
-            }
-            visitedRoutes.add(routeName);
-            const orderedPools = this.sortRoutePools(routePools);
-            for (const poolTier of orderedPools) {
-                const { providerKey, poolTargets, tierId, failureHint } = this.trySelectFromTier(routeName, poolTier, stickyKey, estimatedTokens, features, disabledProviders, disabledKeysMap, allowedProviders, disabledModels, requiredProviderKeys, allowAliasRotation);
-                if (providerKey) {
-                    return { providerKey, routeUsed: routeName, pool: poolTargets, poolId: tierId };
-                }
-                if (failureHint) {
-                    attempted.push(failureHint);
-                }
-            }
-        }
-        const requestedRoute = this.normalizeRouteAlias(classification.routeName || DEFAULT_ROUTE);
-        throw new VirtualRouterError(`All providers unavailable for route ${requestedRoute}`, VirtualRouterErrorCode.PROVIDER_NOT_AVAILABLE, { routeName: requestedRoute, attempted });
+        // legacy helper kept for backward compatibility; selection logic moved to engine-selection.ts
+        return selectProviderImpl(this.normalizeRouteAlias(classification.routeName || DEFAULT_ROUTE), metadata, classification, features, state, {
+            routing: this.routing,
+            providerRegistry: this.providerRegistry,
+            healthManager: this.healthManager,
+            contextAdvisor: this.contextAdvisor,
+            loadBalancer: this.loadBalancer,
+            isProviderCoolingDown: (key) => this.isProviderCoolingDown(key),
+            resolveStickyKey: (m) => this.resolveStickyKey(m)
+        }, { routingState: state });
     }
     extractProviderId(providerKey) {
         const firstDot = providerKey.indexOf('.');
@@ -749,7 +502,7 @@ export class VirtualRouterEngine {
         ]));
         const disabledModels = new Map(Array.from(state.disabledModels.entries()).map(([provider, models]) => [provider, new Set(models)]));
         // 初始候选集合：sticky 池中的所有 key
-        let candidates = Array.from(stickyKeySet);
+        let candidates = Array.from(stickyKeySet).filter((key) => !this.isProviderCoolingDown(key));
         // 应用 provider 白名单 / 黑名单
         if (allowedProviders.size > 0) {
             candidates = candidates.filter((key) => {
@@ -798,21 +551,8 @@ export class VirtualRouterEngine {
         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 } = this.trySelectFromTier('sticky', tier, stickyKey, estimatedTokens, features, disabledProviders, disabledKeysMap, allowedProviders, disabledModels, stickyKeySet, allowAliasRotation);
-        if (!providerKey) {
-            return null;
-        }
-        return {
-            providerKey,
-            routeUsed: 'sticky',
-            pool: poolTargets,
-            poolId: tierId
-        };
+        // delegate to selection module
+        return null;
     }
     extractKeyAlias(providerKey) {
         const parts = providerKey.split('.');
@@ -851,87 +591,19 @@ export class VirtualRouterEngine {
         }
         return null;
     }
-    mapProviderError(event) {
-        // NOTE: mapProviderError is the only place where VirtualRouter translates providerErrorCenter
-        // events into health signals. Classification is intentionally coarse; upstream providers
-        // are expected to set event.recoverable explicitly when they know an error is safe to retry.
-        if (!event || !event.runtime) {
-            return null;
+    // mapProviderError/applySeriesCooldown moved to engine-health.ts
+    extractExcludedProviderKeySet(metadata) {
+        if (!metadata) {
+            return new Set();
         }
-        const runtime = event.runtime;
-        const providerKey = runtime.providerKey ||
-            (runtime.target && typeof runtime.target === 'object' ? runtime.target.providerKey : undefined);
-        if (!providerKey) {
-            return null;
+        const raw = metadata.excludedProviderKeys;
+        if (!Array.isArray(raw) || raw.length === 0) {
+            return new Set();
         }
-        const routeName = runtime.routeName;
-        const statusCode = event.status;
-        const code = event.code?.toUpperCase() ?? 'ERR_UNKNOWN';
-        const stage = event.stage?.toLowerCase() ?? 'unknown';
-        const recoverable = event.recoverable === true;
-        // 默认策略：只有显式可恢复的错误才视为非致命；其余一律按致命处理。
-        // 注意：provider 层已经对 429 做了「连续 4 次升级为不可恢复」的判断，这里不再把所有 429 强行当作可恢复。
-        let fatal = !recoverable;
-        let reason = this.deriveReason(code, stage, statusCode);
-        let cooldownOverrideMs;
-        // 401 / 402 / 500 / 524 以及所有未被标记为可恢复的错误一律视为不可恢复
-        if (statusCode === 401 || statusCode === 402 || statusCode === 403 || code.includes('AUTH')) {
-            fatal = true;
-            cooldownOverrideMs = Math.max(10 * 60_000, this.providerHealthConfig().fatalCooldownMs ?? 10 * 60_000);
-            reason = 'auth';
-        }
-        else if (statusCode === 429 && !recoverable) {
-            // 连续 429 已在 provider 层被升级为不可恢复：这里按致命限流处理（长冷却，等同熔断）
-            fatal = true;
-            cooldownOverrideMs = Math.max(10 * 60_000, this.providerHealthConfig().fatalCooldownMs ?? 10 * 60_000);
-            reason = 'rate_limit';
-        }
-        else if (statusCode && statusCode >= 500) {
-            fatal = true;
-            cooldownOverrideMs = Math.max(5 * 60_000, this.providerHealthConfig().fatalCooldownMs ?? 5 * 60_000);
-            reason = 'upstream_error';
-        }
-        else if (stage.includes('compat')) {
-            fatal = true;
-            cooldownOverrideMs = Math.max(10 * 60_000, this.providerHealthConfig().fatalCooldownMs ?? 10 * 60_000);
-            reason = 'compatibility';
-        }
-        return {
-            providerKey,
-            routeName,
-            reason,
-            fatal,
-            statusCode,
-            errorCode: code,
-            retryable: recoverable,
-            // 是否影响健康由 provider 层决定；这里仅在 event.affectsHealth !== false 时才计入健康状态
-            affectsHealth: event.affectsHealth !== false,
-            cooldownOverrideMs,
-            metadata: {
-                ...event.runtime,
-                stage,
-                eventCode: code,
-                originalMessage: event.message,
-                statusCode
-            }
-        };
-    }
-    deriveReason(code, stage, statusCode) {
-        if (code.includes('RATE') || code.includes('429'))
-            return 'rate_limit';
-        if (code.includes('AUTH') || statusCode === 401 || statusCode === 403)
-            return 'auth';
-        if (stage.includes('compat'))
-            return 'compatibility';
-        if (code.includes('SSE'))
-            return 'sse';
-        if (code.includes('TIMEOUT') || statusCode === 408 || statusCode === 504)
-            return 'timeout';
-        if (statusCode && statusCode >= 500)
-            return 'upstream_error';
-        if (statusCode && statusCode >= 400)
-            return 'client_error';
-        return 'unknown';
+        const normalized = raw
+            .map((value) => (typeof value === 'string' ? value.trim() : ''))
+            .filter((value) => Boolean(value));
+        return new Set(normalized);
     }
     buildRouteCandidates(requestedRoute, classificationCandidates, features) {
         const forceVision = this.routeHasForceFlag('vision');
@@ -1081,50 +753,6 @@ export class VirtualRouterEngine {
         }
         return flattened;
     }
-    buildHitReason(routeUsed, providerKey, classification, features, mode) {
-        const reasoning = classification.reasoning || '';
-        let primary = reasoning.split('|')[0] || '';
-        const commandDetail = features.lastAssistantToolLabel;
-        const isStickyMode = mode === 'sticky';
-        if (isStickyMode &&
-            (routeUsed === 'tools' || routeUsed === 'thinking' || routeUsed === 'coding')) {
-            // sticky 模式下不再把 tools/thinking/coding 作为主标签，统一折叠为 sticky，
-            // 避免日志中出现 "tools:last-tool-*" 这类误导性前缀。
-            primary = '';
-        }
-        const base = (() => {
-            if (routeUsed === 'tools') {
-                const label = isStickyMode ? 'sticky' : 'tools';
-                return this.decorateWithDetail(primary || label, primary, commandDetail);
-            }
-            if (routeUsed === 'thinking') {
-                const label = isStickyMode ? 'sticky' : 'thinking';
-                return this.decorateWithDetail(primary || label, primary, commandDetail);
-            }
-            if (routeUsed === 'coding') {
-                const label = isStickyMode ? 'sticky' : 'coding';
-                return this.decorateWithDetail(primary || label, primary, commandDetail);
-            }
-            if (routeUsed === 'web_search' || routeUsed === 'search') {
-                return this.decorateWithDetail(primary || routeUsed, primary, commandDetail);
-            }
-            if (routeUsed === DEFAULT_ROUTE && classification.fallback) {
-                if (isStickyMode) {
-                    return primary || 'sticky:default';
-                }
-                return primary || 'fallback:default';
-            }
-            if (primary) {
-                return primary;
-            }
-            return routeUsed ? `route:${routeUsed}` : 'route:unknown';
-        })();
-        const contextDetail = this.describeContextUsage(providerKey, features.estimatedTokens);
-        if (contextDetail) {
-            return `${base}|context:${contextDetail}`;
-        }
-        return base;
-    }
     isRoutingStateEmpty(state) {
         if (!state) {
             return true;
@@ -1147,109 +775,28 @@ export class VirtualRouterEngine {
         }
         saveRoutingInstructionStateAsync(key, state);
     }
-    decorateWithDetail(baseLabel, primaryReason, detail) {
-        const normalizedDetail = detail && detail.trim();
-        if (!normalizedDetail) {
-            return primaryReason || baseLabel;
-        }
-        if (primaryReason) {
-            return `${primaryReason}(${normalizedDetail})`;
-        }
-        return `${baseLabel}(${normalizedDetail})`;
-    }
-    formatVirtualRouterHit(routeName, poolId, providerKey, modelId, hitReason, stickyScope) {
-        try {
-            // 生成本地时间戳
-            const now = new Date();
-            const hours = String(now.getHours()).padStart(2, '0');
-            const minutes = String(now.getMinutes()).padStart(2, '0');
-            const seconds = String(now.getSeconds()).padStart(2, '0');
-            const timestamp = `${hours}:${minutes}:${seconds}`;
-            const prefixColor = '\x1b[38;5;208m';
-            const reset = '\x1b[0m';
-            const timeColor = '\x1b[90m'; // 灰色
-            const stickyColor = '\x1b[33m'; // 黄色
-            const routeColor = this.resolveRouteColor(routeName);
-            const prefix = `${prefixColor}[virtual-router-hit]${reset}`;
-            const timeLabel = `${timeColor}${timestamp}${reset}`;
-            const { providerLabel, resolvedModel } = this.describeTargetProvider(providerKey, modelId);
-            const routeLabel = poolId ? `${routeName}/${poolId}` : routeName;
-            const targetLabel = `${routeLabel} -> ${providerLabel}${resolvedModel ? '.' + resolvedModel : ''}`;
-            const stickyLabel = stickyScope ? ` ${stickyColor}[sticky:${stickyScope}]${reset}` : '';
-            const reasonLabel = hitReason ? ` reason=${hitReason}` : '';
-            return `${prefix} ${timeLabel} ${routeColor}${targetLabel}${stickyLabel}${reasonLabel}${reset}`;
-        }
-        catch {
-            const now = new Date();
-            const timestamp = now.toLocaleTimeString('zh-CN', { hour12: false });
-            const routeLabel = poolId ? `${routeName}/${poolId}` : routeName;
-            const stickyLabel = stickyScope ? ` [sticky:${stickyScope}]` : '';
-            return `[virtual-router-hit] ${timestamp} ${routeLabel} -> ${providerKey}${modelId ? '.' + modelId : ''}${stickyLabel}${hitReason ? ` reason=${hitReason}` : ''}`;
-        }
-    }
-    resolveRouteColor(routeName) {
-        const reset = '\x1b[0m';
-        const map = {
-            tools: '\x1b[38;5;214m',
-            thinking: '\x1b[34m',
-            coding: '\x1b[35m',
-            longcontext: '\x1b[38;5;141m',
-            web_search: '\x1b[32m',
-            search: '\x1b[38;5;34m',
-            vision: '\x1b[38;5;207m',
-            background: '\x1b[90m'
-        };
-        return map[routeName] ?? '\x1b[36m';
-    }
-    describeContextUsage(providerKey, estimatedTokens) {
-        if (typeof estimatedTokens !== 'number' || !Number.isFinite(estimatedTokens) || estimatedTokens <= 0) {
-            return undefined;
-        }
-        let limit = DEFAULT_MODEL_CONTEXT_TOKENS;
-        try {
-            const profile = this.providerRegistry.get(providerKey);
-            if (profile?.maxContextTokens && Number.isFinite(profile.maxContextTokens)) {
-                limit = profile.maxContextTokens;
-            }
-        }
-        catch {
-            limit = DEFAULT_MODEL_CONTEXT_TOKENS;
-        }
-        if (!limit || limit <= 0) {
-            return undefined;
+    markProviderCooldown(providerKey, cooldownMs) {
+        if (!providerKey) {
+            return;
         }
-        const ratio = estimatedTokens / limit;
-        const threshold = this.contextRouting?.warnRatio ?? 0.9;
-        if (ratio < threshold) {
-            return undefined;
+        const ttl = typeof cooldownMs === 'number' ? Math.round(cooldownMs) : Number.NaN;
+        if (!Number.isFinite(ttl) || ttl <= 0) {
+            return;
         }
-        return `${ratio.toFixed(2)}/${Math.round(limit)}`;
-    }
-    describeTargetProvider(providerKey, fallbackModelId) {
-        const parsed = this.parseProviderKey(providerKey);
-        if (!parsed) {
-            return { providerLabel: providerKey, resolvedModel: fallbackModelId };
-        }
-        const aliasLabel = parsed.keyAlias ? `${parsed.providerId}[${parsed.keyAlias}]` : parsed.providerId;
-        const resolvedModel = parsed.modelId || fallbackModelId;
-        return { providerLabel: aliasLabel, resolvedModel };
+        this.providerCooldowns.set(providerKey, Date.now() + ttl);
     }
-    parseProviderKey(providerKey) {
-        const trimmed = typeof providerKey === 'string' ? providerKey.trim() : '';
-        if (!trimmed) {
-            return null;
+    isProviderCoolingDown(providerKey) {
+        if (!providerKey) {
+            return false;
         }
-        const parts = trimmed.split('.');
-        if (parts.length < 2) {
-            return { providerId: trimmed };
+        const expiry = this.providerCooldowns.get(providerKey);
+        if (!expiry) {
+            return false;
         }
-        if (parts.length === 2) {
-            return { providerId: parts[0], modelId: parts[1] };
+        if (Date.now() >= expiry) {
+            this.providerCooldowns.delete(providerKey);
+            return false;
         }
-        return {
-            providerId: parts[0],
-            keyAlias: parts[1],
-            modelId: parts.slice(2).join('.')
-        };
+        return true;
     }
 }