@jsonstudio/rcc 0.90.352 → 0.90.367

package/vendor/llmswitch-core/dist/router/virtual-router/engine-legacy.js

@@ -0,0 +1,245 @@
+import { ProviderHealthManager } from './health-manager.js';
+import { ProviderRegistry } from './provider-registry.js';
+import { RouteLoadBalancer } from './load-balancer.js';
+import { RoutingClassifier } from './classifier.js';
+import { ContextAdvisor } from './context-advisor.js';
+import { getStatsCenter } from '../../telemetry/stats-center.js';
+import { loadRoutingInstructionStateSync, saveRoutingInstructionStateAsync, saveRoutingInstructionStateSync } from './sticky-session-store.js';
+import { resolveStickyKey as resolveStickyKeyImpl, resolveSessionScope as resolveSessionScopeImpl } from './engine/routing-state/keys.js';
+import { RouteAnalytics } from './engine/route-analytics.js';
+import { StickySessionManager } from './engine/sticky-session-manager.js';
+import { CooldownManager } from './engine/cooldown-manager.js';
+import { VirtualRouterEngine as NativeVirtualRouterEngine } from './engine.js';
+import { updateDeps as updateDepsImpl, initialize as initializeImpl } from './engine-legacy/config.js';
+import { handleProviderError as handleProviderErrorImpl, handleProviderFailure as handleProviderFailureImpl, handleProviderSuccess as handleProviderSuccessImpl, buildHealthSnapshot as buildHealthSnapshotImpl, persistHealthSnapshot as persistHealthSnapshotImpl, markProviderCooldown as markProviderCooldownImpl, clearProviderCooldown as clearProviderCooldownImpl, isProviderCoolingDown as isProviderCoolingDownImpl, getProviderCooldownRemainingMs as getProviderCooldownRemainingMsImpl, restoreHealthFromStore as restoreHealthFromStoreImpl } from './engine-legacy/health.js';
+import { selectProvider as selectProviderImpl, selectFromCandidates as selectFromCandidatesImpl, selectFromStickyPool as selectFromStickyPoolImpl, extractExcludedProviderKeySet as extractExcludedProviderKeySetImpl } from './engine-legacy/selection-core.js';
+import { parseDirectProviderModel as parseDirectProviderModelImpl, shouldFallbackDirectModelForMedia as shouldFallbackDirectModelForMediaImpl } from './engine-legacy/direct-model.js';
+import { normalizeRouteAlias as normalizeRouteAliasImpl, buildRouteCandidates as buildRouteCandidatesImpl, reorderForInlineVision as reorderForInlineVisionImpl, reorderForPreferredModel as reorderForPreferredModelImpl, routeSupportsModel as routeSupportsModelImpl, routeSupportsInlineVision as routeSupportsInlineVisionImpl, sortByPriority as sortByPriorityImpl, routeWeight as routeWeightImpl, routeHasForceFlag as routeHasForceFlagImpl, routeHasTargets as routeHasTargetsImpl, hasPrimaryPool as hasPrimaryPoolImpl, sortRoutePools as sortRoutePoolsImpl, flattenPoolTargets as flattenPoolTargetsImpl } from './engine-legacy/route-utils.js';
+import { resolveSelectionPenalty as resolveSelectionPenaltyImpl, resolveInstructionProcessModeForSelection as resolveInstructionProcessModeForSelectionImpl, resolveInstructionTarget as resolveInstructionTargetImpl, filterCandidatesByRoutingState as filterCandidatesByRoutingStateImpl, buildStickyRouteCandidatesFromFiltered as buildStickyRouteCandidatesFromFilteredImpl } from './engine-legacy/selection-state.js';
+const ALLOW_ENGINE_LEGACY_IMPORTS = process.env.LLMSWITCH_ALLOW_ENGINE_LEGACY_IMPORTS === '1' ||
+    process.env.ROUTECODEX_ALLOW_ENGINE_LEGACY_IMPORTS === '1';
+if (!ALLOW_ENGINE_LEGACY_IMPORTS) {
+    throw new Error('[engine-legacy] import is fail-closed. Set LLMSWITCH_ALLOW_ENGINE_LEGACY_IMPORTS=1 only for explicit compatibility/debug work.');
+}
+function warnLegacyCompatibilitySurface(method) {
+    const enabled = process.env.LLMSWITCH_WARN_LEGACY_SURFACES === '1' ||
+        process.env.ROUTECODEX_WARN_LEGACY_SURFACES === '1';
+    if (!enabled) {
+        return;
+    }
+    try {
+        // eslint-disable-next-line no-console
+        console.warn(`[engine-legacy] compatibility surface invoked: ${method}. Do not add new runtime logic to engine-legacy helpers.`);
+    }
+    catch {
+        // best-effort only
+    }
+}
+export class VirtualRouterEngine {
+    routing = {};
+    providerRegistry = new ProviderRegistry();
+    healthManager = new ProviderHealthManager();
+    loadBalancer = new RouteLoadBalancer();
+    classifier = new RoutingClassifier({});
+    contextAdvisor = new ContextAdvisor();
+    contextRouting;
+    routeAnalytics = new RouteAnalytics();
+    stickySessionManager = new StickySessionManager();
+    cooldownManager;
+    antigravityLeasePersistence = { loadedOnce: false, loadedMtimeMs: null, flushTimer: null };
+    debug = console; // thin hook; host may monkey-patch for colored logging
+    healthConfig = null;
+    statsCenter = getStatsCenter();
+    // Derived flags from VirtualRouterConfig/routing used by process / response layers.
+    webSearchForce = false;
+    healthStore;
+    routingStateStore = {
+        loadSync: loadRoutingInstructionStateSync,
+        saveAsync: saveRoutingInstructionStateAsync,
+        saveSync: saveRoutingInstructionStateSync
+    };
+    routingInstructionState = new Map();
+    quotaView;
+    nativeEngine;
+    /**
+     * Backward-compatible test/debug surface used by existing regression scripts.
+     * Keep this as a read-only view over StickySessionManager storage.
+     */
+    get antigravitySessionAliasStore() {
+        return this.nativeEngine.antigravitySessionAliasStore;
+    }
+    constructor(deps) {
+        this.nativeEngine = new NativeVirtualRouterEngine(deps);
+        this.cooldownManager = new CooldownManager({
+            healthStore: deps?.healthStore,
+            healthConfig: this.healthConfig,
+            quotaView: deps?.quotaView
+        });
+        if (deps?.healthStore) {
+            this.healthStore = deps.healthStore;
+        }
+        if (deps?.routingStateStore) {
+            this.routingStateStore = deps.routingStateStore;
+        }
+        if (deps?.quotaView) {
+            this.quotaView = deps.quotaView;
+        }
+    }
+    updateDeps(deps) {
+        updateDepsImpl(this, deps);
+        this.nativeEngine.updateDeps(deps);
+    }
+    initialize(config) {
+        initializeImpl(this, config);
+        this.nativeEngine.initialize(config);
+    }
+    route(request, metadata) {
+        return this.nativeEngine.route(request, metadata);
+    }
+    getStopMessageState(metadata) {
+        return this.nativeEngine.getStopMessageState(metadata);
+    }
+    getPreCommandState(metadata) {
+        return this.nativeEngine.getPreCommandState(metadata);
+    }
+    handleProviderFailure(event) {
+        handleProviderFailureImpl(this, event);
+        this.nativeEngine.handleProviderFailure(event);
+    }
+    handleProviderError(event) {
+        handleProviderErrorImpl(this, event);
+        this.nativeEngine.handleProviderError(event);
+    }
+    handleProviderSuccess(event) {
+        handleProviderSuccessImpl(this, event);
+        this.nativeEngine.handleProviderSuccess(event);
+    }
+    getStatus() {
+        return this.nativeEngine.getStatus();
+    }
+    normalizeRouteAlias(routeName) {
+        warnLegacyCompatibilitySurface('normalizeRouteAlias');
+        return normalizeRouteAliasImpl(routeName);
+    }
+    buildRouteCandidates(requestedRoute, classificationCandidates, features) {
+        warnLegacyCompatibilitySurface('buildRouteCandidates');
+        return buildRouteCandidatesImpl(this, requestedRoute, classificationCandidates, features);
+    }
+    reorderForInlineVision(routeNames) {
+        warnLegacyCompatibilitySurface('reorderForInlineVision');
+        return reorderForInlineVisionImpl(this, routeNames);
+    }
+    reorderForPreferredModel(routeNames, modelId) {
+        warnLegacyCompatibilitySurface('reorderForPreferredModel');
+        return reorderForPreferredModelImpl(this, routeNames, modelId);
+    }
+    routeSupportsModel(routeName, modelId) {
+        warnLegacyCompatibilitySurface('routeSupportsModel');
+        return routeSupportsModelImpl(this, routeName, modelId);
+    }
+    routeSupportsInlineVision(routeName) {
+        warnLegacyCompatibilitySurface('routeSupportsInlineVision');
+        return routeSupportsInlineVisionImpl(this, routeName);
+    }
+    sortByPriority(routeNames) {
+        warnLegacyCompatibilitySurface('sortByPriority');
+        return sortByPriorityImpl(routeNames);
+    }
+    routeWeight(routeName) {
+        warnLegacyCompatibilitySurface('routeWeight');
+        return routeWeightImpl(routeName);
+    }
+    routeHasForceFlag(routeName) {
+        warnLegacyCompatibilitySurface('routeHasForceFlag');
+        return routeHasForceFlagImpl(this, routeName);
+    }
+    routeHasTargets(pools) {
+        warnLegacyCompatibilitySurface('routeHasTargets');
+        return routeHasTargetsImpl(this, pools);
+    }
+    hasPrimaryPool(pools) {
+        warnLegacyCompatibilitySurface('hasPrimaryPool');
+        return hasPrimaryPoolImpl(this, pools);
+    }
+    sortRoutePools(pools) {
+        warnLegacyCompatibilitySurface('sortRoutePools');
+        return sortRoutePoolsImpl(this, pools);
+    }
+    flattenPoolTargets(pools) {
+        warnLegacyCompatibilitySurface('flattenPoolTargets');
+        return flattenPoolTargetsImpl(this, pools);
+    }
+    markProviderCooldown(providerKey, cooldownMs) {
+        markProviderCooldownImpl(this, providerKey, cooldownMs);
+        this.nativeEngine.markProviderCooldown(providerKey, cooldownMs);
+    }
+    clearProviderCooldown(providerKey) {
+        clearProviderCooldownImpl(this, providerKey);
+        this.nativeEngine.clearProviderCooldown(providerKey);
+    }
+    isProviderCoolingDown(providerKey) {
+        return isProviderCoolingDownImpl(this, providerKey);
+    }
+    getProviderCooldownRemainingMs(providerKey) {
+        return getProviderCooldownRemainingMsImpl(this, providerKey);
+    }
+    restoreHealthFromStore() {
+        restoreHealthFromStoreImpl(this);
+    }
+    buildHealthSnapshot() {
+        return buildHealthSnapshotImpl(this);
+    }
+    persistHealthSnapshot() {
+        persistHealthSnapshotImpl(this);
+    }
+    parseDirectProviderModel(model) {
+        return parseDirectProviderModelImpl(this, model);
+    }
+    shouldFallbackDirectModelForMedia(direct, features) {
+        return shouldFallbackDirectModelForMediaImpl(this, direct, features);
+    }
+    selectProvider(requestedRoute, metadata, classification, features, routingState) {
+        warnLegacyCompatibilitySurface('selectProvider');
+        return selectProviderImpl(this, requestedRoute, metadata, classification, features, routingState);
+    }
+    selectFromCandidates(routes, metadata, classification, features, state, requiredProviderKeys, allowAliasRotation) {
+        warnLegacyCompatibilitySurface('selectFromCandidates');
+        return selectFromCandidatesImpl(this, routes, metadata, classification, features, state, requiredProviderKeys, allowAliasRotation);
+    }
+    selectFromStickyPool(stickyKeySet, metadata, features, state, allowAliasRotation) {
+        warnLegacyCompatibilitySurface('selectFromStickyPool');
+        return selectFromStickyPoolImpl(this, stickyKeySet, metadata, features, state, allowAliasRotation);
+    }
+    extractExcludedProviderKeySet(metadata) {
+        warnLegacyCompatibilitySurface('extractExcludedProviderKeySet');
+        return extractExcludedProviderKeySetImpl(this, metadata);
+    }
+    resolveSelectionPenalty(providerKey) {
+        warnLegacyCompatibilitySurface('resolveSelectionPenalty');
+        return resolveSelectionPenaltyImpl(this, providerKey);
+    }
+    resolveInstructionProcessModeForSelection(providerKey, routingState) {
+        warnLegacyCompatibilitySurface('resolveInstructionProcessModeForSelection');
+        return resolveInstructionProcessModeForSelectionImpl(this, providerKey, routingState);
+    }
+    resolveInstructionTarget(target) {
+        warnLegacyCompatibilitySurface('resolveInstructionTarget');
+        return resolveInstructionTargetImpl(this, target);
+    }
+    buildStickyRouteCandidatesFromFiltered(filteredCandidates, stickyKeySet) {
+        warnLegacyCompatibilitySurface('buildStickyRouteCandidatesFromFiltered');
+        return buildStickyRouteCandidatesFromFilteredImpl(this, filteredCandidates, stickyKeySet);
+    }
+    filterCandidatesByRoutingState(routes, state) {
+        warnLegacyCompatibilitySurface('filterCandidatesByRoutingState');
+        return filterCandidatesByRoutingStateImpl(this, routes, state);
+    }
+    resolveStickyKey(metadata) {
+        warnLegacyCompatibilitySurface('resolveStickyKey');
+        return resolveStickyKeyImpl(metadata);
+    }
+    resolveSessionScope(metadata) {
+        warnLegacyCompatibilitySurface('resolveSessionScope');
+        return resolveSessionScopeImpl(metadata);
+    }
+}

package/vendor/llmswitch-core/dist/router/virtual-router/engine-logging.d.ts

@@ -0,0 +1,67 @@
+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';
+import type { VirtualRouterHitEvent } from '../../telemetry/stats-center.js';
+type LoggingDeps = {
+    providerRegistry: ProviderRegistry;
+    contextRouting: VirtualRouterContextRoutingConfig | undefined;
+};
+export type StopMessageRuntimeSummary = {
+    hasAny: boolean;
+    safeText?: string;
+    mode: 'on' | 'off' | 'auto' | 'unset';
+    maxRepeats: number;
+    used: number;
+    remaining: number;
+    active: boolean;
+    updatedAt?: number;
+    lastUsedAt?: number;
+};
+export type VirtualRouterHitRecord = {
+    timestampMs: number;
+    requestId?: string;
+    sessionId?: string;
+    routeName: string;
+    poolId?: string;
+    providerKey: string;
+    modelId?: string;
+    hitReason?: string;
+    stickyScope?: string;
+    requestTokens?: number;
+    selectionPenalty?: number;
+    stopMessage: StopMessageRuntimeSummary;
+};
+export type VirtualRouterHitEventMeta = {
+    requestId: string;
+    entryEndpoint?: string;
+};
+export declare function createVirtualRouterHitRecord(input: {
+    requestId?: string;
+    sessionId?: string;
+    routeName: string;
+    poolId?: string;
+    providerKey: string;
+    modelId?: string;
+    hitReason?: string;
+    stickyScope?: string;
+    routingState?: RoutingInstructionState;
+    requestTokens?: number;
+    selectionPenalty?: number;
+    timestampMs?: number;
+}): VirtualRouterHitRecord;
+export declare function toVirtualRouterHitEvent(record: VirtualRouterHitRecord, meta: VirtualRouterHitEventMeta): VirtualRouterHitEvent;
+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 resolveRouteColor(routeName: string): string;
+export declare function resolveSessionColor(sessionId?: string): string;
+export declare function buildHitReason(routeUsed: string, providerKey: string, classification: ClassificationResult, features: RoutingFeatures, mode: RoutingInstructionMode | undefined, deps: LoggingDeps): string;
+export declare function formatVirtualRouterHit(record: VirtualRouterHitRecord): string;
+export {};

package/vendor/llmswitch-core/dist/router/virtual-router/engine-logging.js

@@ -0,0 +1,356 @@
+import { DEFAULT_MODEL_CONTEXT_TOKENS, DEFAULT_ROUTE } from './types.js';
+const DEFAULT_STOP_MESSAGE_MAX_REPEATS = 10;
+function summarizeStopMessageRuntime(state) {
+    if (!state) {
+        return {
+            hasAny: false,
+            mode: 'unset',
+            maxRepeats: 0,
+            used: 0,
+            remaining: -1,
+            active: false
+        };
+    }
+    const text = typeof state.stopMessageText === 'string' ? state.stopMessageText.trim() : '';
+    const safeText = text ? (text.length > 24 ? `${text.slice(0, 21)}…` : text) : undefined;
+    const modeRaw = typeof state.stopMessageStageMode === 'string' ? state.stopMessageStageMode.trim().toLowerCase() : '';
+    const mode = modeRaw === 'on' || modeRaw === 'off' || modeRaw === 'auto' ? modeRaw : 'unset';
+    const parsedMaxRepeats = typeof state.stopMessageMaxRepeats === 'number' && Number.isFinite(state.stopMessageMaxRepeats)
+        ? Math.max(0, Math.floor(state.stopMessageMaxRepeats))
+        : 0;
+    const hasGoalText = Boolean(text);
+    const maxRepeats = parsedMaxRepeats > 0
+        ? parsedMaxRepeats
+        : hasGoalText && (mode === 'on' || mode === 'auto')
+            ? DEFAULT_STOP_MESSAGE_MAX_REPEATS
+            : 0;
+    const used = typeof state.stopMessageUsed === 'number' && Number.isFinite(state.stopMessageUsed)
+        ? Math.max(0, Math.floor(state.stopMessageUsed))
+        : 0;
+    const remaining = maxRepeats > 0 ? Math.max(0, maxRepeats - used) : -1;
+    const active = mode !== 'off' && hasGoalText && maxRepeats > 0;
+    const updatedAt = typeof state.stopMessageUpdatedAt === 'number' && Number.isFinite(state.stopMessageUpdatedAt)
+        ? state.stopMessageUpdatedAt
+        : undefined;
+    const lastUsedAt = typeof state.stopMessageLastUsedAt === 'number' && Number.isFinite(state.stopMessageLastUsedAt)
+        ? state.stopMessageLastUsedAt
+        : undefined;
+    const hasAny = hasGoalText || maxRepeats > 0 || used > 0;
+    return {
+        hasAny,
+        ...(safeText ? { safeText } : {}),
+        mode,
+        maxRepeats,
+        used,
+        remaining,
+        active,
+        ...(updatedAt ? { updatedAt } : {}),
+        ...(lastUsedAt ? { lastUsedAt } : {})
+    };
+}
+function normalizePositiveInteger(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
+        return undefined;
+    }
+    return Math.floor(value);
+}
+function normalizeRoundedInteger(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        return undefined;
+    }
+    return Math.max(0, Math.round(value));
+}
+export function createVirtualRouterHitRecord(input) {
+    return {
+        timestampMs: typeof input.timestampMs === 'number' && Number.isFinite(input.timestampMs)
+            ? input.timestampMs
+            : Date.now(),
+        ...(input.requestId ? { requestId: input.requestId } : {}),
+        ...(input.sessionId ? { sessionId: input.sessionId } : {}),
+        routeName: input.routeName,
+        ...(input.poolId ? { poolId: input.poolId } : {}),
+        providerKey: input.providerKey,
+        ...(input.modelId ? { modelId: input.modelId } : {}),
+        ...(input.hitReason ? { hitReason: input.hitReason } : {}),
+        ...(input.stickyScope ? { stickyScope: input.stickyScope } : {}),
+        ...(typeof normalizeRoundedInteger(input.requestTokens) === 'number'
+            ? { requestTokens: normalizeRoundedInteger(input.requestTokens) }
+            : {}),
+        ...(typeof normalizePositiveInteger(input.selectionPenalty) === 'number'
+            ? { selectionPenalty: normalizePositiveInteger(input.selectionPenalty) }
+            : {}),
+        stopMessage: summarizeStopMessageRuntime(input.routingState)
+    };
+}
+export function toVirtualRouterHitEvent(record, meta) {
+    return {
+        requestId: meta.requestId,
+        timestamp: record.timestampMs,
+        entryEndpoint: meta.entryEndpoint || '/v1/chat/completions',
+        routeName: record.routeName,
+        pool: record.poolId || record.routeName,
+        providerKey: record.providerKey,
+        ...(record.modelId ? { modelId: record.modelId } : {}),
+        ...(record.hitReason ? { reason: record.hitReason } : {}),
+        ...(typeof record.requestTokens === 'number' ? { requestTokens: record.requestTokens } : {}),
+        ...(typeof record.selectionPenalty === 'number' ? { selectionPenalty: record.selectionPenalty } : {}),
+        stopMessageActive: record.stopMessage.active,
+        ...(record.stopMessage.mode !== 'unset' ? { stopMessageMode: record.stopMessage.mode } : {}),
+        ...(record.stopMessage.remaining >= 0 ? { stopMessageRemaining: record.stopMessage.remaining } : {})
+    };
+}
+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 };
+}
+export function resolveRouteColor(routeName) {
+    const map = {
+        multimodal: '\x1b[38;5;45m',
+        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';
+}
+export function resolveSessionColor(sessionId) {
+    const palette = [
+        '\x1b[31m',
+        '\x1b[32m',
+        '\x1b[33m',
+        '\x1b[34m',
+        '\x1b[35m',
+        '\x1b[36m',
+        '\x1b[91m',
+        '\x1b[92m',
+        '\x1b[93m',
+        '\x1b[94m',
+        '\x1b[95m',
+        '\x1b[96m',
+        '\x1b[38;5;202m',
+        '\x1b[38;5;208m',
+        '\x1b[38;5;214m',
+        '\x1b[38;5;220m',
+        '\x1b[38;5;45m',
+        '\x1b[38;5;51m',
+        '\x1b[38;5;39m',
+        '\x1b[38;5;75m',
+        '\x1b[38;5;141m',
+        '\x1b[38;5;177m',
+        '\x1b[38;5;171m',
+        '\x1b[38;5;207m'
+    ];
+    const normalized = typeof sessionId === 'string' ? sessionId.trim() : '';
+    if (!normalized) {
+        return '\x1b[36m';
+    }
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < normalized.length; i += 1) {
+        hash ^= normalized.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193) >>> 0;
+    }
+    hash ^= hash >>> 16;
+    hash = Math.imul(hash, 0x7feb352d) >>> 0;
+    hash ^= hash >>> 15;
+    hash = Math.imul(hash, 0x846ca68b) >>> 0;
+    hash ^= hash >>> 16;
+    return palette[hash % palette.length];
+}
+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(record) {
+    try {
+        const now = new Date(record.timestampMs);
+        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 stopColor = '\x1b[38;5;214m';
+        const prefix = `${prefixColor}[virtual-router-hit]${reset}`;
+        const timeLabel = `${timeColor}${timestamp}${reset}`;
+        const { providerLabel, resolvedModel } = describeTargetProvider(record.providerKey, record.modelId);
+        const routeLabel = record.poolId ? `${record.routeName}/${record.poolId}` : record.routeName;
+        const targetLabel = `${routeLabel} -> ${providerLabel}${resolvedModel ? '.' + resolvedModel : ''}`;
+        const requestId = typeof record.requestId === 'string' ? record.requestId : '';
+        const requestLabel = requestId && !requestId.includes('unknown') ? ` req=${requestId}` : '';
+        const sessionId = typeof record.sessionId === 'string' ? record.sessionId.trim() : '';
+        const sessionLabel = sessionId ? ` sid=${sessionId}` : '';
+        const routeColor = (sessionId ? resolveSessionColor(sessionId) : undefined) || resolveRouteColor(record.routeName);
+        const stickyText = formatStickyScope(record.stickyScope);
+        const stickyLabel = stickyText ? ` ${stickyColor}[sticky:${stickyText}]${reset}` : '';
+        const reasonLabel = record.hitReason ? ` reason=${record.hitReason}` : '';
+        const requestTokenLabel = typeof record.requestTokens === 'number' && Number.isFinite(record.requestTokens)
+            ? ` reqTokens=${Math.max(0, Math.round(record.requestTokens))}`
+            : '';
+        const penaltyLabel = typeof record.selectionPenalty === 'number' && Number.isFinite(record.selectionPenalty) && record.selectionPenalty > 0
+            ? ` penalty=${Math.floor(record.selectionPenalty)}`
+            : '';
+        let stopLabel = '';
+        const stop = record.stopMessage;
+        if (stop.hasAny) {
+            const parts = [
+                stop.safeText ? `"${stop.safeText}"` : '"(mode-only)"',
+                `mode=${stop.mode}`,
+                `round=${stop.maxRepeats > 0 ? `${stop.used}/${stop.maxRepeats}` : `${stop.used}/-`}`,
+                `active=${stop.active ? 'yes' : 'no'}`,
+                `left=${stop.remaining >= 0 ? stop.remaining : 'n/a'}`
+            ];
+            if (stop.updatedAt) {
+                parts.push(`set=${new Date(stop.updatedAt).toLocaleString(undefined, { hour12: false })}`);
+            }
+            if (stop.lastUsedAt) {
+                parts.push(`last=${new Date(stop.lastUsedAt).toLocaleString(undefined, { hour12: false })}`);
+            }
+            stopLabel = ` ${stopColor}[stopMessage:${parts.join(' ')}]${reset}`;
+        }
+        return `${prefix} ${timeLabel}${requestLabel}${sessionLabel} ${routeColor}${targetLabel}${stickyLabel}${reasonLabel}${requestTokenLabel}${penaltyLabel}${stopLabel}${reset}`;
+    }
+    catch {
+        const now = new Date(record.timestampMs);
+        const timestamp = now.toLocaleTimeString('zh-CN', { hour12: false });
+        const routeLabel = record.poolId ? `${record.routeName}/${record.poolId}` : record.routeName;
+        const stickyText = formatStickyScope(record.stickyScope);
+        const stickyLabel = stickyText ? ` [sticky:${stickyText}]` : '';
+        const requestId = typeof record.requestId === 'string' ? record.requestId : '';
+        const requestLabel = requestId && !requestId.includes('unknown') ? ` req=${requestId}` : '';
+        const sessionId = typeof record.sessionId === 'string' ? record.sessionId.trim() : '';
+        const sessionLabel = sessionId ? ` sid=${sessionId}` : '';
+        const requestTokenLabel = typeof record.requestTokens === 'number' && Number.isFinite(record.requestTokens)
+            ? ` reqTokens=${Math.max(0, Math.round(record.requestTokens))}`
+            : '';
+        const penaltyLabel = typeof record.selectionPenalty === 'number' && Number.isFinite(record.selectionPenalty) && record.selectionPenalty > 0
+            ? ` penalty=${Math.floor(record.selectionPenalty)}`
+            : '';
+        let stopLabel = '';
+        const stop = record.stopMessage;
+        if (stop.hasAny) {
+            const safeText = stop.safeText ? `"${stop.safeText}"` : '"(mode-only)"';
+            const rounds = stop.maxRepeats > 0 ? `${stop.used}/${stop.maxRepeats}` : `${stop.used}/-`;
+            const left = stop.remaining >= 0 ? String(stop.remaining) : 'n/a';
+            stopLabel = ` [stopMessage:${safeText} mode=${stop.mode} round=${rounds} active=${stop.active ? 'yes' : 'no'} left=${left}]`;
+        }
+        return `[virtual-router-hit] ${timestamp}${requestLabel}${sessionLabel} ${routeLabel} -> ${record.providerKey}${record.modelId ? '.' + record.modelId : ''}${stickyLabel}${record.hitReason ? ` reason=${record.hitReason}` : ''}${requestTokenLabel}${penaltyLabel}${stopLabel}`;
+    }
+}