@jsonstudio/llms 0.6.473 → 0.6.568

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

@@ -0,0 +1,423 @@
+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;
+    }
+    if (event.affectsHealth === false) {
+        return;
+    }
+    if (event.fatal) {
+        healthManager.tripProvider(event.providerKey, event.reason, event.cooldownOverrideMs);
+    }
+    else if (event.reason === 'rate_limit' && event.statusCode === 429) {
+        // 对非致命的 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);
+    }
+}
+export function mapProviderErrorImpl(event, healthConfig) {
+    if (!event || !event.runtime) {
+        return null;
+    }
+    const runtime = event.runtime;
+    const providerKey = runtime.providerKey ||
+        (runtime.target && typeof runtime.target === 'object'
+            ? runtime.target.providerKey
+            : undefined);
+    if (!providerKey) {
+        return null;
+    }
+    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;
+    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') || isOAuthAuth406) {
+        fatal = true;
+        cooldownOverrideMs = Math.max(10 * 60_000, healthConfig.fatalCooldownMs ?? 10 * 60_000);
+        reason = 'auth';
+    }
+    else if (statusCode === 429 && !recoverable) {
+        fatal = true;
+        cooldownOverrideMs = Math.max(10 * 60_000, healthConfig.fatalCooldownMs ?? 10 * 60_000);
+        reason = 'rate_limit';
+    }
+    else if (statusCode && statusCode >= 500) {
+        fatal = true;
+        cooldownOverrideMs = Math.max(5 * 60_000, healthConfig.fatalCooldownMs ?? 5 * 60_000);
+        reason = 'upstream_error';
+    }
+    else if (stage.includes('compat')) {
+        fatal = true;
+        cooldownOverrideMs = Math.max(10 * 60_000, healthConfig.fatalCooldownMs ?? 10 * 60_000);
+        reason = 'compatibility';
+    }
+    return {
+        providerKey,
+        routeName,
+        reason,
+        fatal,
+        statusCode,
+        errorCode: code,
+        retryable: recoverable,
+        affectsHealth: event.affectsHealth !== false,
+        cooldownOverrideMs,
+        metadata: {
+            ...event.runtime,
+            stage,
+            eventCode: code,
+            originalMessage: event.message,
+            statusCode
+        }
+    };
+}
+export function applySeriesCooldownImpl(event, providerRegistry, healthManager, markProviderCooldown, debug) {
+    const seriesDetail = extractSeriesCooldownDetail(event);
+    if (!seriesDetail) {
+        return;
+    }
+    const targetKeys = resolveSeriesCooldownTargets(seriesDetail, event, providerRegistry);
+    if (targetKeys.length === 0) {
+        debug?.log?.('[virtual-router] series cooldown skipped: no targets', {
+            providerId: seriesDetail.providerId,
+            providerKey: seriesDetail.providerKey,
+            series: seriesDetail.series
+        });
+        return;
+    }
+    const affected = [];
+    for (const providerKey of targetKeys) {
+        try {
+            const profile = providerRegistry.get(providerKey);
+            const modelSeries = resolveModelSeries(profile.modelId);
+            if (modelSeries !== seriesDetail.series) {
+                continue;
+            }
+            healthManager.tripProvider(providerKey, 'rate_limit', seriesDetail.cooldownMs);
+            markProviderCooldown(providerKey, seriesDetail.cooldownMs);
+            affected.push(providerKey);
+        }
+        catch {
+            // ignore lookup failures; invalid keys may show up if config drifted
+        }
+    }
+    if (affected.length) {
+        debug?.log?.('[virtual-router] series cooldown', {
+            providerId: seriesDetail.providerId,
+            providerKey: seriesDetail.providerKey,
+            series: seriesDetail.series,
+            cooldownMs: seriesDetail.cooldownMs,
+            affected
+        });
+    }
+}
+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) => {
+        if (typeof key !== 'string') {
+            return;
+        }
+        const trimmed = key.trim();
+        if (!trimmed) {
+            return;
+        }
+        if (providerRegistry.has(trimmed)) {
+            candidates.add(trimmed);
+        }
+    };
+    push(detail.providerKey);
+    const runtimeKey = (event.runtime?.target && typeof event.runtime.target === 'object'
+        ? event.runtime.target.providerKey
+        : undefined) || event.runtime?.providerKey;
+    push(runtimeKey);
+    return Array.from(candidates);
+}
+function extractSeriesCooldownDetail(event) {
+    if (!event || !event.details || typeof event.details !== 'object') {
+        return null;
+    }
+    const raw = event.details[SERIES_COOLDOWN_DETAIL_KEY];
+    if (!raw || typeof raw !== 'object') {
+        return null;
+    }
+    const record = raw;
+    const providerIdRaw = record.providerId;
+    const seriesRaw = record.series;
+    const providerKeyRaw = record.providerKey;
+    const cooldownRaw = record.cooldownMs;
+    if (typeof providerIdRaw !== 'string' || !providerIdRaw.trim()) {
+        return null;
+    }
+    const normalizedSeries = typeof seriesRaw === 'string' ? seriesRaw.trim().toLowerCase() : '';
+    if (normalizedSeries !== 'gemini-pro' && normalizedSeries !== 'gemini-flash' && normalizedSeries !== 'claude') {
+        return null;
+    }
+    const cooldownMs = typeof cooldownRaw === 'number'
+        ? cooldownRaw
+        : typeof cooldownRaw === 'string'
+            ? Number.parseFloat(cooldownRaw)
+            : Number.NaN;
+    if (!Number.isFinite(cooldownMs) || cooldownMs <= 0) {
+        return null;
+    }
+    return {
+        providerId: providerIdRaw.trim(),
+        ...(typeof providerKeyRaw === 'string' && providerKeyRaw.trim().length
+            ? { providerKey: providerKeyRaw.trim() }
+            : {}),
+        series: normalizedSeries,
+        cooldownMs: Math.round(cooldownMs)
+    };
+}
+export function 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';
+}
+function resolveModelSeries(modelId) {
+    if (!modelId) {
+        return 'default';
+    }
+    const lower = modelId.toLowerCase();
+    if (lower.includes('claude') || lower.includes('opus')) {
+        return 'claude';
+    }
+    if (lower.includes('flash')) {
+        return 'gemini-flash';
+    }
+    if (lower.includes('gemini') || lower.includes('pro')) {
+        return 'gemini-pro';
+    }
+    return 'default';
+}

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

@@ -0,0 +1,20 @@
+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;
+};
+export declare function formatStickyScope(scope?: string): string | undefined;
+export declare function parseProviderKey(providerKey: string): {
+    providerId: string;
+    keyAlias?: string;
+    modelId?: string;
+} | null;
+export declare function describeTargetProvider(providerKey: string, fallbackModelId?: string): {
+    providerLabel: string;
+    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, routingState?: RoutingInstructionState): string;
+export {};

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

@@ -0,0 +1,197 @@
+import { DEFAULT_MODEL_CONTEXT_TOKENS, DEFAULT_ROUTE } from './types.js';
+export function formatStickyScope(scope) {
+    if (!scope || scope.trim().length === 0) {
+        return undefined;
+    }
+    const normalized = scope.trim();
+    const maxLength = 20;
+    if (normalized.length <= maxLength) {
+        return normalized;
+    }
+    const delimiterIndex = normalized.indexOf(':');
+    const prefix = delimiterIndex > 0 ? normalized.slice(0, delimiterIndex + 1) : '';
+    const body = delimiterIndex > 0 ? normalized.slice(delimiterIndex + 1) : normalized;
+    if (body.length <= 8) {
+        return `${prefix}${body}`;
+    }
+    return `${prefix}${body.slice(0, 4)}…${body.slice(-4)}`;
+}
+export function parseProviderKey(providerKey) {
+    const trimmed = typeof providerKey === 'string' ? providerKey.trim() : '';
+    if (!trimmed) {
+        return null;
+    }
+    const parts = trimmed.split('.');
+    if (parts.length < 2) {
+        return { providerId: trimmed };
+    }
+    if (parts.length === 2) {
+        return { providerId: parts[0], modelId: parts[1] };
+    }
+    return {
+        providerId: parts[0],
+        keyAlias: parts[1],
+        modelId: parts.slice(2).join('.')
+    };
+}
+export function describeTargetProvider(providerKey, fallbackModelId) {
+    const parsed = 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 };
+}
+function resolveRouteColor(routeName) {
+    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';
+}
+function describeContextUsage(providerKey, estimatedTokens, deps) {
+    if (typeof estimatedTokens !== 'number' || !Number.isFinite(estimatedTokens) || estimatedTokens <= 0) {
+        return undefined;
+    }
+    let limit = DEFAULT_MODEL_CONTEXT_TOKENS;
+    try {
+        const profile = deps.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;
+    }
+    const ratio = estimatedTokens / limit;
+    const threshold = deps.contextRouting?.warnRatio ?? 0.9;
+    if (ratio < threshold) {
+        return undefined;
+    }
+    return `${ratio.toFixed(2)}/${Math.round(limit)}`;
+}
+function decorateWithDetail(baseLabel, primaryReason, detail) {
+    const normalizedDetail = detail && detail.trim();
+    if (!normalizedDetail) {
+        return primaryReason || baseLabel;
+    }
+    if (primaryReason) {
+        return `${primaryReason}(${normalizedDetail})`;
+    }
+    return `${baseLabel}(${normalizedDetail})`;
+}
+export function buildHitReason(routeUsed, providerKey, classification, features, mode, deps) {
+    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')) {
+        primary = '';
+    }
+    const base = (() => {
+        if (routeUsed === 'tools') {
+            const label = isStickyMode ? 'sticky' : 'tools';
+            return decorateWithDetail(primary || label, primary, commandDetail);
+        }
+        if (routeUsed === 'thinking') {
+            const label = isStickyMode ? 'sticky' : 'thinking';
+            return decorateWithDetail(primary || label, primary, commandDetail);
+        }
+        if (routeUsed === 'coding') {
+            const label = isStickyMode ? 'sticky' : 'coding';
+            return decorateWithDetail(primary || label, primary, commandDetail);
+        }
+        if (routeUsed === 'web_search' || routeUsed === 'search') {
+            return 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 = describeContextUsage(providerKey, features.estimatedTokens, deps);
+    if (contextDetail) {
+        return `${base}|context:${contextDetail}`;
+    }
+    return base;
+}
+export function formatVirtualRouterHit(routeName, poolId, providerKey, modelId, hitReason, stickyScope, routingState) {
+    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 = 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);
+        const routeLabel = poolId ? `${routeName}/${poolId}` : routeName;
+        const targetLabel = `${routeLabel} -> ${providerLabel}${resolvedModel ? '.' + resolvedModel : ''}`;
+        const stickyText = formatStickyScope(stickyScope);
+        const stickyLabel = stickyText ? ` ${stickyColor}[sticky:${stickyText}]${reset}` : '';
+        const reasonLabel = 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;
+            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();
+        const timestamp = now.toLocaleTimeString('zh-CN', { hour12: false });
+        const routeLabel = poolId ? `${routeName}/${poolId}` : routeName;
+        const stickyText = formatStickyScope(stickyScope);
+        const stickyLabel = stickyText ? ` [sticky:${stickyText}]` : '';
+        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-selection.d.ts

@@ -0,0 +1,32 @@
+import type { ClassificationResult, RoutePoolTier, RouterMetadataInput, RoutingFeatures } from './types.js';
+import type { RoutingInstructionState } from './routing-instructions.js';
+import type { ContextAdvisor } from './context-advisor.js';
+import type { RouteLoadBalancer } from './load-balancer.js';
+import type { ProviderHealthManager } from './health-manager.js';
+import type { ProviderRegistry } from './provider-registry.js';
+type SelectionDeps = {
+    routing: Record<string, RoutePoolTier[]>;
+    providerRegistry: ProviderRegistry;
+    healthManager: ProviderHealthManager;
+    contextAdvisor: ContextAdvisor;
+    loadBalancer: RouteLoadBalancer;
+    isProviderCoolingDown: (providerKey: string) => boolean;
+    resolveStickyKey: (metadata: RouterMetadataInput) => string | undefined;
+};
+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;
+};
+export declare function selectFromStickyPool(stickyKeySet: Set<string>, metadata: RouterMetadataInput, features: RoutingFeatures, state: RoutingInstructionState, deps: SelectionDeps, options: {
+    allowAliasRotation?: boolean;
+}): {
+    providerKey: string;
+    routeUsed: string;
+    pool: string[];
+    poolId?: string;
+} | null;
+export {};