@jsonstudio/rcc 0.89.333 → 0.89.524

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/engine.js

@@ -5,6 +5,7 @@ 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 { getStatsCenter } from '../../telemetry/stats-center.js';
 export class VirtualRouterEngine {
     routing = {};
     providerRegistry = new ProviderRegistry();
@@ -16,6 +17,9 @@ export class VirtualRouterEngine {
     routeStats = new Map();
     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;
     initialize(config) {
         this.validateConfig(config);
         this.routing = config.routing;
@@ -27,6 +31,7 @@ export class VirtualRouterEngine {
         this.classifier = new RoutingClassifier(config.classifier);
         this.contextRouting = config.contextRouting ?? { warnRatio: 0.9, hardLimit: false };
         this.contextAdvisor.configure(this.contextRouting);
+        this.webSearchForce = config.webSearch?.force === true;
         this.routeStats = new Map();
         for (const routeName of Object.keys(this.routing)) {
             this.routeStats.set(routeName, { hits: 0 });
@@ -34,27 +39,56 @@ export class VirtualRouterEngine {
     }
     route(request, metadata) {
         const features = buildRoutingFeatures(request, metadata);
-        const classification = this.classifier.classify(features);
-        const routeName = classification.routeName || DEFAULT_ROUTE;
-        const selection = this.selectProvider(routeName, metadata, classification, features);
-        const target = this.providerRegistry.buildTarget(selection.providerKey);
+        const classification = metadata.routeHint && metadata.routeHint.trim()
+            ? {
+                routeName: metadata.routeHint.trim(),
+                confidence: 1,
+                reasoning: `route_hint:${metadata.routeHint.trim()}`,
+                fallback: false,
+                candidates: [metadata.routeHint.trim()]
+            }
+            : this.classifier.classify(features);
+        const requestedRoute = this.normalizeRouteAlias(classification.routeName || DEFAULT_ROUTE);
+        const selection = this.selectProvider(requestedRoute, metadata, classification, features);
+        const baseTarget = this.providerRegistry.buildTarget(selection.providerKey);
+        const forceVision = this.routeHasForceFlag('vision');
+        const target = {
+            ...baseTarget,
+            ...(this.webSearchForce ? { forceWebSearch: true } : {}),
+            ...(forceVision ? { forceVision: true } : {})
+        };
         this.healthManager.recordSuccess(selection.providerKey);
         this.incrementRouteStat(selection.routeUsed, selection.providerKey);
+        try {
+            this.statsCenter.recordVirtualRouterHit({
+                requestId: metadata.requestId,
+                timestamp: Date.now(),
+                entryEndpoint: metadata.entryEndpoint || '/v1/chat/completions',
+                routeName: selection.routeUsed,
+                pool: selection.poolId || selection.routeUsed,
+                providerKey: selection.providerKey,
+                modelId: target.modelId || undefined
+            });
+        }
+        catch {
+            // stats must never break routing
+        }
         const hitReason = this.buildHitReason(selection.routeUsed, selection.providerKey, classification, features);
-        const formatted = this.formatVirtualRouterHit(selection.routeUsed, selection.providerKey, target.modelId || '', hitReason);
+        const formatted = this.formatVirtualRouterHit(selection.routeUsed, selection.poolId, selection.providerKey, target.modelId || '', hitReason);
         if (formatted) {
             this.debug?.log?.(formatted);
         }
         else {
             this.debug?.log?.('[virtual-router-hit]', selection.routeUsed, selection.providerKey, target.modelId || '', hitReason ? `reason=${hitReason}` : '');
         }
-        const didFallback = selection.routeUsed !== routeName || classification.fallback;
+        const didFallback = selection.routeUsed !== requestedRoute;
         return {
             target,
             decision: {
                 routeName: selection.routeUsed,
                 providerKey: selection.providerKey,
                 pool: selection.pool,
+                poolId: selection.poolId,
                 confidence: classification.confidence,
                 reasoning: classification.reasoning,
                 fallback: didFallback
@@ -63,6 +97,7 @@ export class VirtualRouterEngine {
                 routeName: selection.routeUsed,
                 providerKey: selection.providerKey,
                 pool: selection.pool,
+                poolId: selection.poolId,
                 reasoning: classification.reasoning,
                 fallback: didFallback,
                 confidence: classification.confidence
@@ -92,10 +127,10 @@ export class VirtualRouterEngine {
     }
     getStatus() {
         const routes = {};
-        for (const [route, pool] of Object.entries(this.routing)) {
+        for (const [route, pools] of Object.entries(this.routing)) {
             const stats = this.routeStats.get(route) ?? { hits: 0 };
             routes[route] = {
-                providers: [...pool],
+                providers: this.flattenPoolTargets(pools),
                 hits: stats.hits,
                 lastUsedProvider: stats.lastProvider
             };
@@ -105,6 +140,14 @@ export class VirtualRouterEngine {
             health: this.healthManager.getSnapshot()
         };
     }
+    /**
+     * 将分类器产生的逻辑路由名直接归一化为配置中的路由键。
+     * 不再维护 "websearch" 之类的别名，调用方应显式使用 "web_search" 或 "search" 等实际路由名。
+     */
+    normalizeRouteAlias(routeName) {
+        const base = routeName && routeName.trim() ? routeName.trim() : DEFAULT_ROUTE;
+        return base;
+    }
     validateConfig(config) {
         if (!config.routing || typeof config.routing !== 'object') {
             throw new VirtualRouterError('routing configuration is required', VirtualRouterErrorCode.CONFIG_ERROR);
@@ -112,32 +155,39 @@ export class VirtualRouterEngine {
         if (!config.providers || Object.keys(config.providers).length === 0) {
             throw new VirtualRouterError('providers configuration is required', VirtualRouterErrorCode.CONFIG_ERROR);
         }
-        const defaultPool = config.routing[DEFAULT_ROUTE];
-        if (!Array.isArray(defaultPool) || defaultPool.length === 0) {
+        const defaultPools = config.routing[DEFAULT_ROUTE];
+        if (!this.routeHasTargets(defaultPools)) {
             throw new VirtualRouterError('default route must be configured with at least one provider', VirtualRouterErrorCode.CONFIG_ERROR);
         }
+        if (!this.hasPrimaryPool(defaultPools)) {
+            throw new VirtualRouterError('default route must define at least one non-backup pool', VirtualRouterErrorCode.CONFIG_ERROR);
+        }
         const providerKeys = new Set(Object.keys(config.providers));
-        for (const [routeName, pool] of Object.entries(config.routing)) {
-            if (!Array.isArray(pool) || !pool.length) {
+        for (const [routeName, pools] of Object.entries(config.routing)) {
+            if (!this.routeHasTargets(pools)) {
                 if (routeName === DEFAULT_ROUTE) {
                     throw new VirtualRouterError('default route cannot be empty', VirtualRouterErrorCode.CONFIG_ERROR);
                 }
                 continue;
             }
-            for (const providerKey of pool) {
-                if (!providerKeys.has(providerKey)) {
-                    throw new VirtualRouterError(`Route ${routeName} references unknown provider ${providerKey}`, VirtualRouterErrorCode.CONFIG_ERROR);
+            for (const pool of pools) {
+                if (!Array.isArray(pool.targets) || !pool.targets.length) {
+                    continue;
+                }
+                for (const providerKey of pool.targets) {
+                    if (!providerKeys.has(providerKey)) {
+                        throw new VirtualRouterError(`Route ${routeName} references unknown provider ${providerKey}`, VirtualRouterErrorCode.CONFIG_ERROR);
+                    }
                 }
             }
         }
     }
     selectProvider(requestedRoute, metadata, classification, features) {
-        const candidates = this.buildRouteCandidates(requestedRoute, classification.candidates);
+        const candidates = this.buildRouteCandidates(requestedRoute, classification.candidates, features);
         const stickyKey = this.resolveStickyKey(metadata);
         const attempted = [];
         const visitedRoutes = new Set();
-        const fallbackRoute = this.resolveFallbackRoute();
-        const routeQueue = this.initializeRouteQueue(candidates, fallbackRoute);
+        const routeQueue = this.initializeRouteQueue(candidates);
         const estimatedTokens = typeof features.estimatedTokens === 'number' && Number.isFinite(features.estimatedTokens)
             ? Math.max(0, features.estimatedTokens)
             : 0;
@@ -146,33 +196,93 @@ export class VirtualRouterEngine {
             if (visitedRoutes.has(routeName)) {
                 continue;
             }
-            const pool = this.routing[routeName];
-            if (!Array.isArray(pool) || pool.length === 0) {
+            const routePools = this.routing[routeName];
+            if (!this.routeHasTargets(routePools)) {
                 visitedRoutes.add(routeName);
-                attempted.push(routeName);
-                continue;
-            }
-            const contextResult = this.contextAdvisor.classify(pool, estimatedTokens, (key) => this.providerRegistry.get(key));
-            if (this.maybeDeferToFallback(routeName, contextResult, routeQueue, visitedRoutes, fallbackRoute)) {
+                attempted.push(`${routeName}:empty`);
                 continue;
             }
             visitedRoutes.add(routeName);
-            const prioritizedPools = this.buildContextCandidatePools(contextResult);
-            for (const candidatePool of prioritizedPools) {
-                const providerKey = this.loadBalancer.select({
-                    routeName,
-                    candidates: candidatePool,
-                    stickyKey,
-                    availabilityCheck: (key) => this.healthManager.isAvailable(key)
-                });
+            const orderedPools = this.sortRoutePools(routePools);
+            for (const poolTier of orderedPools) {
+                const { providerKey, poolTargets, tierId, failureHint } = this.trySelectFromTier(routeName, poolTier, stickyKey, estimatedTokens, features);
                 if (providerKey) {
-                    return { providerKey, routeUsed: routeName, pool };
+                    return { providerKey, routeUsed: routeName, pool: poolTargets, poolId: tierId };
+                }
+                if (failureHint) {
+                    attempted.push(failureHint);
                 }
             }
-            attempted.push(this.describeAttempt(routeName, contextResult));
         }
         throw new VirtualRouterError(`All providers unavailable for route ${requestedRoute}`, VirtualRouterErrorCode.PROVIDER_NOT_AVAILABLE, { routeName: requestedRoute, attempted });
     }
+    trySelectFromTier(routeName, tier, stickyKey, estimatedTokens, features) {
+        let targets = Array.isArray(tier.targets) ? tier.targets : [];
+        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,
+                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)
+        };
+    }
     incrementRouteStat(routeName, providerKey) {
         if (!this.routeStats.has(routeName)) {
             this.routeStats.set(routeName, { hits: 0, lastProvider: providerKey });
@@ -185,63 +295,34 @@ export class VirtualRouterEngine {
     providerHealthConfig() {
         return this.healthManager.getConfig();
     }
-    initializeRouteQueue(candidates, fallbackRoute) {
-        const queue = Array.from(new Set(candidates));
-        if (fallbackRoute && !queue.includes(fallbackRoute)) {
-            queue.push(fallbackRoute);
-        }
-        return queue;
-    }
-    resolveFallbackRoute() {
-        const candidate = this.contextRouting?.fallbackRoute;
-        if (!candidate) {
-            return undefined;
-        }
-        const pool = this.routing[candidate];
-        if (!Array.isArray(pool) || pool.length === 0) {
-            return undefined;
-        }
-        return candidate;
-    }
-    maybeDeferToFallback(routeName, contextResult, queue, visited, fallbackRoute) {
-        if (!fallbackRoute || fallbackRoute === routeName || visited.has(fallbackRoute)) {
-            return false;
-        }
-        if (!this.contextAdvisor.prefersFallback(contextResult)) {
-            return false;
-        }
-        const fallbackPool = this.routing[fallbackRoute];
-        if (!Array.isArray(fallbackPool) || fallbackPool.length === 0) {
-            return false;
-        }
-        queue.unshift(routeName);
-        queue.unshift(fallbackRoute);
-        return true;
+    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);
         }
-        if (result.overflow.length && this.contextAdvisor.allowsOverflow()) {
-            ordered.push(result.overflow);
-        }
+        // ratio >= 1 视为上下文溢出，直接标记为不可用
         return ordered;
     }
-    describeAttempt(routeName, result) {
+    describeAttempt(routeName, poolId, result) {
+        const prefix = poolId ? `${routeName}:${poolId}` : routeName;
         if (result.safe.length > 0) {
-            return `${routeName}:health`;
+            return `${prefix}:health`;
         }
         if (result.risky.length > 0) {
-            return `${routeName}:context_risky`;
+            return `${prefix}:context_risky`;
         }
         if (result.overflow.length > 0) {
-            return `${routeName}:context_overflow`;
+            return `${prefix}:max_context_window`;
         }
-        return routeName;
+        return prefix;
     }
     resolveStickyKey(metadata) {
         const resume = metadata.responsesResume;
@@ -332,12 +413,32 @@ export class VirtualRouterEngine {
             return 'client_error';
         return 'unknown';
     }
-    buildRouteCandidates(requestedRoute, classificationCandidates) {
-        const normalized = requestedRoute || DEFAULT_ROUTE;
-        const baseList = classificationCandidates && classificationCandidates.length
-            ? classificationCandidates
-            : [normalized];
-        const ordered = this.sortByPriority(baseList);
+    buildRouteCandidates(requestedRoute, classificationCandidates, features) {
+        const forceVision = this.routeHasForceFlag('vision');
+        const normalized = this.normalizeRouteAlias(requestedRoute || DEFAULT_ROUTE);
+        const baseList = [];
+        if (classificationCandidates && classificationCandidates.length) {
+            for (const candidate of classificationCandidates) {
+                baseList.push(this.normalizeRouteAlias(candidate));
+            }
+        }
+        else if (normalized) {
+            baseList.push(normalized);
+        }
+        // 当检测到当前请求包含图片时，确保 default/thinking 也参与候选集，
+        // 以便优先尝试内建多模态模型（Responses/Gemini），再回落到 vision 路由池。
+        if (features.hasImageAttachment && !forceVision) {
+            const visionAwareRoutes = [DEFAULT_ROUTE, 'thinking'];
+            for (const routeName of visionAwareRoutes) {
+                if (this.routeHasTargets(this.routing[routeName]) && !baseList.includes(routeName)) {
+                    baseList.push(routeName);
+                }
+            }
+        }
+        let ordered = this.sortByPriority(baseList);
+        if (features.hasImageAttachment && !forceVision) {
+            ordered = this.reorderForInlineVision(ordered);
+        }
         const deduped = [];
         for (const routeName of ordered) {
             if (routeName && !deduped.includes(routeName)) {
@@ -347,17 +448,59 @@ export class VirtualRouterEngine {
         if (!deduped.includes(DEFAULT_ROUTE)) {
             deduped.push(DEFAULT_ROUTE);
         }
-        const filtered = deduped.filter((routeName) => {
-            const pool = this.routing[routeName];
-            return Array.isArray(pool) && pool.length > 0;
-        });
-        if (!filtered.includes(DEFAULT_ROUTE) &&
-            Array.isArray(this.routing[DEFAULT_ROUTE]) &&
-            this.routing[DEFAULT_ROUTE].length > 0) {
+        const filtered = deduped.filter((routeName) => this.routeHasTargets(this.routing[routeName]));
+        if (!filtered.includes(DEFAULT_ROUTE) && this.routeHasTargets(this.routing[DEFAULT_ROUTE])) {
             filtered.push(DEFAULT_ROUTE);
         }
         return filtered.length ? filtered : [DEFAULT_ROUTE];
     }
+    reorderForInlineVision(routeNames) {
+        const unique = Array.from(new Set(routeNames.filter(Boolean)));
+        if (!unique.length) {
+            return unique;
+        }
+        // 仅当 default/thinking 中存在 Responses/Gemini 提供方时，才将其提前作为「一次完成」优先级。
+        const inlinePreferred = [];
+        const inlineRoutes = [DEFAULT_ROUTE, 'thinking'];
+        for (const routeName of inlineRoutes) {
+            if (this.routeSupportsInlineVision(routeName) && !inlinePreferred.includes(routeName)) {
+                inlinePreferred.push(routeName);
+            }
+        }
+        if (!inlinePreferred.length) {
+            return unique;
+        }
+        const remaining = [];
+        for (const routeName of unique) {
+            if (!inlinePreferred.includes(routeName)) {
+                remaining.push(routeName);
+            }
+        }
+        return [...inlinePreferred, ...remaining];
+    }
+    routeSupportsInlineVision(routeName) {
+        const pools = this.routing[routeName];
+        if (!Array.isArray(pools)) {
+            return false;
+        }
+        for (const pool of pools) {
+            if (!Array.isArray(pool.targets)) {
+                continue;
+            }
+            for (const providerKey of pool.targets) {
+                try {
+                    const profile = this.providerRegistry.get(providerKey);
+                    if (profile.providerType === 'responses' || profile.providerType === 'gemini') {
+                        return true;
+                    }
+                }
+                catch {
+                    // ignore unknown provider keys during capability probing
+                }
+            }
+        }
+        return false;
+    }
     sortByPriority(routeNames) {
         return [...routeNames].sort((a, b) => this.routeWeight(a) - this.routeWeight(b));
     }
@@ -365,6 +508,59 @@ export class VirtualRouterEngine {
         const idx = ROUTE_PRIORITY.indexOf(routeName);
         return idx >= 0 ? idx : ROUTE_PRIORITY.length;
     }
+    routeHasForceFlag(routeName) {
+        const pools = this.routing[routeName];
+        if (!Array.isArray(pools)) {
+            return false;
+        }
+        return pools.some((pool) => pool.force);
+    }
+    routeHasTargets(pools) {
+        if (!Array.isArray(pools)) {
+            return false;
+        }
+        return pools.some((pool) => Array.isArray(pool.targets) && pool.targets.length > 0);
+    }
+    hasPrimaryPool(pools) {
+        if (!Array.isArray(pools)) {
+            return false;
+        }
+        return pools.some((pool) => !pool.backup && Array.isArray(pool.targets) && pool.targets.length > 0);
+    }
+    sortRoutePools(pools) {
+        if (!Array.isArray(pools)) {
+            return [];
+        }
+        return pools
+            .filter((pool) => Array.isArray(pool.targets) && pool.targets.length > 0)
+            .sort((a, b) => {
+            if (a.backup && !b.backup)
+                return 1;
+            if (!a.backup && b.backup)
+                return -1;
+            if (a.priority !== b.priority) {
+                return b.priority - a.priority;
+            }
+            return a.id.localeCompare(b.id);
+        });
+    }
+    flattenPoolTargets(pools) {
+        const flattened = [];
+        if (!Array.isArray(pools)) {
+            return flattened;
+        }
+        for (const pool of pools) {
+            if (!Array.isArray(pool.targets)) {
+                continue;
+            }
+            for (const target of pool.targets) {
+                if (typeof target === 'string' && target && !flattened.includes(target)) {
+                    flattened.push(target);
+                }
+            }
+        }
+        return flattened;
+    }
     buildHitReason(routeUsed, providerKey, classification, features) {
         const reasoning = classification.reasoning || '';
         const primary = reasoning.split('|')[0] || '';
@@ -379,8 +575,8 @@ export class VirtualRouterEngine {
             if (routeUsed === 'coding') {
                 return this.decorateWithDetail(primary || 'coding', primary, commandDetail);
             }
-            if (routeUsed === 'websearch') {
-                return this.decorateWithDetail(primary || 'websearch', primary, commandDetail);
+            if (routeUsed === 'web_search' || routeUsed === 'search') {
+                return this.decorateWithDetail(primary || routeUsed, primary, commandDetail);
             }
             if (routeUsed === DEFAULT_ROUTE && classification.fallback) {
                 return primary || 'fallback:default';
@@ -406,18 +602,31 @@ export class VirtualRouterEngine {
         }
         return `${baseLabel}(${normalizedDetail})`;
     }
-    formatVirtualRouterHit(routeName, providerKey, modelId, hitReason) {
+    formatVirtualRouterHit(routeName, poolId, providerKey, modelId, hitReason) {
         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 routeColor = this.resolveRouteColor(routeName);
             const prefix = `${prefixColor}[virtual-router-hit]${reset}`;
-            const targetLabel = `${routeName} -> ${providerKey}${modelId ? '.' + modelId : ''}`;
+            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 reasonLabel = hitReason ? ` reason=${hitReason}` : '';
-            return `${prefix} ${routeColor}${targetLabel}${reasonLabel}${reset}`;
+            return `${prefix} ${timeLabel} ${routeColor}${targetLabel}${reasonLabel}${reset}`;
         }
         catch {
-            return `[virtual-router-hit] ${routeName} -> ${providerKey}${modelId ? '.' + modelId : ''}${hitReason ? ` reason=${hitReason}` : ''}`;
+            const now = new Date();
+            const timestamp = now.toLocaleTimeString('zh-CN', { hour12: false });
+            const routeLabel = poolId ? `${routeName}/${poolId}` : routeName;
+            return `[virtual-router-hit] ${timestamp} ${routeLabel} -> ${providerKey}${modelId ? '.' + modelId : ''}${hitReason ? ` reason=${hitReason}` : ''}`;
         }
     }
     resolveRouteColor(routeName) {
@@ -427,7 +636,8 @@ export class VirtualRouterEngine {
             thinking: '\x1b[34m',
             coding: '\x1b[35m',
             longcontext: '\x1b[38;5;141m',
-            websearch: '\x1b[32m',
+            web_search: '\x1b[32m',
+            search: '\x1b[38;5;34m',
             vision: '\x1b[38;5;207m',
             background: '\x1b[90m'
         };
@@ -457,4 +667,31 @@ export class VirtualRouterEngine {
         }
         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 };
+    }
+    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('.')
+        };
+    }
 }

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/features.js

@@ -14,7 +14,7 @@ export function buildRoutingFeatures(request, metadata) {
     const estimatedTokens = computeRequestTokens(request, latestUserText);
     const hasThinking = detectKeyword(normalizedUserText, THINKING_KEYWORDS);
     const hasVisionTool = detectVisionTool(request);
-    const hasImageAttachment = hasVisionTool && detectImageAttachment(latestUserMessage);
+    const hasImageAttachment = detectImageAttachment(latestUserMessage);
     const hasCodingTool = detectCodingTool(request);
     const hasWebTool = detectWebTool(request);
     const hasThinkingKeyword = hasThinking || detectExtendedThinkingKeyword(normalizedUserText);