@jsonstudio/llms 0.6.104 → 0.6.141

package/dist/conversion/shared/responses-conversation-store.js

@@ -205,16 +205,29 @@ class ResponsesConversationStore {
     }
     resumeConversation(responseId, submitPayload, options) {
         if (typeof responseId !== 'string' || !responseId.trim()) {
-            throw new Error('Responses conversation requires valid response_id');
+            raiseResumeError('Responses conversation requires valid response_id', {
+                code: 'RESPONSES_RESUME_MISSING_ID',
+                status: 422,
+                origin: 'client'
+            });
         }
         this.prune();
         const entry = this.responseIndex.get(responseId);
         if (!entry) {
-            throw new Error('Responses conversation expired or not found');
+            raiseResumeError('Responses conversation expired or not found', {
+                code: 'RESPONSES_RESUME_NOT_FOUND',
+                status: 500,
+                origin: 'server',
+                details: { responseId }
+            });
         }
         const toolOutputs = Array.isArray(submitPayload.tool_outputs) ? submitPayload.tool_outputs : [];
         if (!toolOutputs.length) {
-            throw new Error('tool_outputs array is required when submitting Responses tool results');
+            raiseResumeError('tool_outputs array is required when submitting Responses tool results', {
+                code: 'RESPONSES_RESUME_MISSING_OUTPUTS',
+                status: 422,
+                origin: 'client'
+            });
         }
         const mergedInput = coerceInputArray(entry.input);
         const normalizedOutputs = normalizeSubmittedToolOutputs(toolOutputs);
@@ -281,6 +294,16 @@ class ResponsesConversationStore {
 }
 const store = new ResponsesConversationStore();
 const RESPONSES_DEBUG = (process.env.ROUTECODEX_RESPONSES_DEBUG || '').trim() === '1';
+function raiseResumeError(message, options) {
+    const err = new Error(message);
+    err.code = options?.code ?? 'RESPONSES_RESUME_ERROR';
+    err.status = options?.status;
+    err.origin = options?.origin;
+    if (options?.details) {
+        err.details = options.details;
+    }
+    throw err;
+}
 export function captureResponsesRequestContext(args) {
     try {
         if (RESPONSES_DEBUG) {

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

@@ -227,9 +227,48 @@ function normalizeResponsesConfig(provider) {
     if (!node) {
         return undefined;
     }
+    const config = {};
     const rawStyle = typeof node.toolCallIdStyle === 'string' ? node.toolCallIdStyle.trim().toLowerCase() : undefined;
     if (rawStyle === 'fc' || rawStyle === 'preserve') {
-        return { toolCallIdStyle: rawStyle };
+        config.toolCallIdStyle = rawStyle;
+    }
+    const streaming = normalizeResponsesStreaming(node.streaming);
+    if (streaming) {
+        config.streaming = streaming;
+    }
+    const instructionsMode = normalizeResponsesInstructionsMode(node.instructionsMode);
+    if (instructionsMode) {
+        config.instructionsMode = instructionsMode;
+    }
+    return Object.keys(config).length ? config : undefined;
+}
+function normalizeResponsesStreaming(value) {
+    if (value === true) {
+        return 'always';
+    }
+    if (value === false) {
+        return 'never';
+    }
+    if (typeof value === 'string') {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === 'always' || normalized === 'true' || normalized === '1' || normalized === 'yes') {
+            return 'always';
+        }
+        if (normalized === 'never' || normalized === 'false' || normalized === '0' || normalized === 'no') {
+            return 'never';
+        }
+        if (normalized === 'auto') {
+            return 'auto';
+        }
+    }
+    return undefined;
+}
+function normalizeResponsesInstructionsMode(value) {
+    if (value === 'inline') {
+        return 'inline';
+    }
+    if (typeof value === 'string' && value.trim().toLowerCase() === 'inline') {
+        return 'inline';
     }
     return undefined;
 }

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

@@ -1,5 +1,18 @@
 import { DEFAULT_ROUTE, ROUTE_PRIORITY } from './types.js';
 const DEFAULT_LONG_CONTEXT_THRESHOLD = 180000;
+const WEBSEARCH_HINT_KEYWORDS = [
+    'web search',
+    'search the web',
+    'search online',
+    'internet search',
+    'search internet',
+    'google it',
+    'bing it',
+    '网络搜索',
+    '上网搜索',
+    '查一下网络',
+    '搜一下网络'
+];
 export class RoutingClassifier {
     config;
     constructor(config) {
@@ -11,13 +24,34 @@ export class RoutingClassifier {
     }
     classify(features) {
         const lastToolCategory = features.lastAssistantToolCategory;
+        const toolCategories = features.assistantToolCategories ?? [];
+        const hasSearchToolCall = toolCategories.includes('search');
+        const hasWriteToolCall = toolCategories.includes('write');
+        const hasReadToolCall = toolCategories.includes('read');
+        const hasOtherToolCall = toolCategories.includes('other');
+        const hasToolCall = toolCategories.length > 0;
         const reachedLongContext = features.estimatedTokens >= (this.config.longContextThresholdTokens ?? DEFAULT_LONG_CONTEXT_THRESHOLD);
-        const thinkingKeywordHit = features.hasThinkingKeyword ||
-            containsKeywords(features.userTextSample, this.config.thinkingKeywords ?? []);
-        const codingContinuation = lastToolCategory === 'write';
-        const thinkingContinuation = lastToolCategory === 'read';
-        const searchContinuation = lastToolCategory === 'search';
-        const toolsContinuation = lastToolCategory === 'other';
+        const routeHint = typeof features.metadata?.routeHint === 'string'
+            ? features.metadata.routeHint.trim().toLowerCase()
+            : undefined;
+        const websearchKeywordHit = containsKeywords(features.userTextSample, WEBSEARCH_HINT_KEYWORDS);
+        const codingContinuation = hasWriteToolCall || lastToolCategory === 'write';
+        const thinkingContinuation = hasReadToolCall || lastToolCategory === 'read';
+        const userInputDetected = typeof features.userTextSample === 'string'
+            ? features.userTextSample.trim().length > 0
+            : false;
+        const searchContinuation = features.assistantCalledWebSearchTool === true;
+        const toolsContinuation = hasOtherToolCall ||
+            searchContinuation ||
+            (hasToolCall && !hasSearchToolCall && !hasWriteToolCall && !hasReadToolCall);
+        const toolContinuationReason = hasOtherToolCall
+            ? formatToolContinuationReason(features.lastAssistantToolName, features.lastAssistantToolDetail)
+            : 'tools:tool-call-detected';
+        const thinkingReason = thinkingContinuation
+            ? 'thinking:last-tool-read'
+            : userInputDetected
+                ? 'thinking:user-input'
+                : 'thinking';
         const evaluationMap = {
             vision: {
                 triggered: features.hasVisionTool && features.hasImageAttachment,
@@ -28,20 +62,20 @@ export class RoutingClassifier {
                 reason: 'longcontext:token-threshold'
             },
             websearch: {
-                triggered: features.hasWebTool || searchContinuation,
-                reason: searchContinuation ? 'websearch:last-tool-search' : 'websearch:web-tools-detected'
+                triggered: routeHint === 'websearch' || websearchKeywordHit,
+                reason: routeHint === 'websearch' ? 'websearch:route-hint' : 'websearch:keywords'
             },
             coding: {
                 triggered: codingContinuation,
                 reason: 'coding:last-tool-write'
             },
             thinking: {
-                triggered: thinkingContinuation || thinkingKeywordHit,
-                reason: thinkingContinuation ? 'thinking:last-tool-read' : 'thinking:keywords'
+                triggered: thinkingContinuation || userInputDetected,
+                reason: thinkingReason
             },
             tools: {
-                triggered: toolsContinuation || features.hasTools || features.hasToolCallResponses,
-                reason: toolsContinuation ? 'tools:last-tool-other' : 'tools:tool-request-detected'
+                triggered: toolsContinuation,
+                reason: toolContinuationReason
             },
             background: {
                 triggered: containsKeywords(features.userTextSample, this.config.backgroundKeywords ?? []),
@@ -100,3 +134,9 @@ function containsKeywords(text, keywords) {
     const normalized = text.toLowerCase();
     return keywords.some((keyword) => normalized.includes(keyword));
 }
+function formatToolContinuationReason(toolName, toolDetail) {
+    const trimmedName = toolName?.trim() || 'tool';
+    const trimmedDetail = toolDetail?.trim();
+    const detailText = trimmedDetail ? `${trimmedName}: ${trimmedDetail}` : trimmedName;
+    return `tools:last-tool-other(${detailText})`;
+}

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

@@ -9,6 +9,9 @@ export declare class VirtualRouterEngine {
     private routeStats;
     private readonly debug;
     private healthConfig;
+    private stickyPlans;
+    private selectionHistory;
+    private providerErrorStreaks;
     initialize(config: VirtualRouterConfig): void;
     route(request: StandardizedRequest | ProcessedRequest, metadata: RouterMetadataInput): {
         target: TargetMetadata;
@@ -25,6 +28,20 @@ export declare class VirtualRouterEngine {
         }>;
         health: import("./types.js").ProviderHealthState[];
     };
+    private consumeSticky;
+    private selectStickyTarget;
+    private buildStickyClassification;
+    private recordSelectionSnapshot;
+    private buildStickyPlan;
+    private storeStickyPlan;
+    private resolveStickyDescriptor;
+    private maybeForceStickyFromHistory;
+    private shouldForceApplyPatchSticky;
+    private extractPreviousRequestId;
+    private pruneStickyPlans;
+    private buildErrorSignature;
+    private bumpProviderErrorStreak;
+    private resetProviderErrorStreak;
     private validateConfig;
     private selectProvider;
     private incrementRouteStat;
@@ -33,7 +50,16 @@ export declare class VirtualRouterEngine {
     private mapProviderError;
     private deriveReason;
     private buildRouteCandidates;
+    private ensureConfiguredClassification;
+    private normalizeCandidateList;
+    private normalizeRouteName;
+    private isRouteConfigured;
     private sortByPriority;
     private routeWeight;
     private buildHitReason;
+    private formatToolIdentifier;
+    private decorateReason;
+    private buildVirtualRouterHitLog;
+    private colorizeVirtualRouterLog;
+    private shouldColorVirtualRouterLogs;
 }

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

@@ -4,6 +4,11 @@ import { RouteLoadBalancer } from './load-balancer.js';
 import { RoutingClassifier } from './classifier.js';
 import { buildRoutingFeatures } from './features.js';
 import { DEFAULT_ROUTE, ROUTE_PRIORITY, VirtualRouterError, VirtualRouterErrorCode } from './types.js';
+const VIRTUAL_ROUTER_HIT_COLOR = '\x1b[38;5;208m';
+const ANSI_RESET = '\x1b[0m';
+const STICKY_PLAN_TTL_MS = 30 * 60 * 1000;
+const ERROR_STREAK_TTL_MS = 10 * 60 * 1000;
+const ERROR_STREAK_THRESHOLD = 4;
 export class VirtualRouterEngine {
     routing = {};
     providerRegistry = new ProviderRegistry();
@@ -13,6 +18,9 @@ export class VirtualRouterEngine {
     routeStats = new Map();
     debug = console; // thin hook; host may monkey-patch for colored logging
     healthConfig = null;
+    stickyPlans = new Map();
+    selectionHistory = new Map();
+    providerErrorStreaks = new Map();
     initialize(config) {
         this.validateConfig(config);
         this.routing = config.routing;
@@ -29,15 +37,42 @@ 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);
+        let stickyActivation = this.consumeSticky(metadata, features);
+        let classification = null;
+        let selection = null;
+        if (stickyActivation) {
+            selection = this.selectStickyTarget(stickyActivation, metadata);
+            if (selection) {
+                classification = this.buildStickyClassification(stickyActivation);
+            }
+            else {
+                stickyActivation = null;
+            }
+        }
+        if (!selection || !classification) {
+            classification = this.classifier.classify(features);
+            classification = this.ensureConfiguredClassification(classification);
+            const routeName = classification.routeName || DEFAULT_ROUTE;
+            selection = this.selectProvider(routeName, metadata, classification);
+        }
+        if (!selection || !classification) {
+            throw new VirtualRouterError('Virtual router failed to select provider', VirtualRouterErrorCode.ROUTE_NOT_FOUND);
+        }
         const target = this.providerRegistry.buildTarget(selection.providerKey);
         this.healthManager.recordSuccess(selection.providerKey);
+        this.resetProviderErrorStreak(selection.providerKey);
         this.incrementRouteStat(selection.routeUsed, selection.providerKey);
-        const hitReason = this.buildHitReason(selection.routeUsed, classification, features);
-        this.debug?.log?.('[virtual-router-hit]', selection.routeUsed, selection.providerKey, target.modelId || '', hitReason ? `reason=${hitReason}` : '');
-        const didFallback = selection.routeUsed !== routeName || classification.fallback;
+        const targetModel = typeof target.modelId === 'string' ? target.modelId : '';
+        this.recordSelectionSnapshot(metadata.requestId, selection.routeUsed, selection.providerKey, targetModel);
+        if (!stickyActivation || stickyActivation.mode === 'forced') {
+            const nextPlan = this.buildStickyPlan(features, selection, target);
+            this.storeStickyPlan(metadata.requestId, nextPlan);
+        }
+        const phase = stickyActivation ? 'execution' : 'hit';
+        const hitReason = this.buildHitReason(selection.routeUsed, classification, features, stickyActivation || undefined, phase);
+        const hitLog = this.buildVirtualRouterHitLog(selection.routeUsed, selection.providerKey, targetModel, hitReason, stickyActivation || undefined, phase);
+        this.debug?.log?.(hitLog);
+        const didFallback = selection.routeUsed !== (classification.routeName || DEFAULT_ROUTE) || classification.fallback;
         return {
             target,
             decision: {
@@ -94,6 +129,199 @@ export class VirtualRouterEngine {
             health: this.healthManager.getSnapshot()
         };
     }
+    consumeSticky(metadata, features) {
+        const prevId = this.extractPreviousRequestId(metadata);
+        if (!prevId) {
+            return null;
+        }
+        this.pruneStickyPlans();
+        const planned = this.stickyPlans.get(prevId);
+        if (planned) {
+            this.stickyPlans.delete(prevId);
+            const activation = {
+                ...planned,
+                sourceRequestId: prevId,
+                mode: 'planned'
+            };
+            if (planned.remainingRounds > 1 && metadata.requestId) {
+                this.stickyPlans.set(metadata.requestId, {
+                    ...planned,
+                    remainingRounds: planned.remainingRounds - 1,
+                    createdAt: Date.now()
+                });
+            }
+            return activation;
+        }
+        return this.maybeForceStickyFromHistory(prevId, features);
+    }
+    selectStickyTarget(sticky, metadata) {
+        if (sticky.strategy === 'target' && sticky.providerKey) {
+            if (!this.healthManager.isAvailable(sticky.providerKey)) {
+                return null;
+            }
+            const pool = this.routing[sticky.routeName] ?? [];
+            return { providerKey: sticky.providerKey, routeUsed: sticky.routeName, pool };
+        }
+        const pool = this.routing[sticky.routeName];
+        if (!Array.isArray(pool) || pool.length === 0) {
+            return null;
+        }
+        const stub = {
+            routeName: sticky.routeName,
+            confidence: 1,
+            reasoning: `sticky:${sticky.reason}`,
+            fallback: false,
+            candidates: [sticky.routeName]
+        };
+        return this.selectProvider(sticky.routeName, metadata, stub);
+    }
+    buildStickyClassification(sticky) {
+        return {
+            routeName: sticky.routeName,
+            confidence: 1,
+            reasoning: `sticky:${sticky.reason}`,
+            fallback: false,
+            candidates: [sticky.routeName]
+        };
+    }
+    recordSelectionSnapshot(requestId, routeName, providerKey, modelId) {
+        if (!requestId || !providerKey) {
+            return;
+        }
+        this.selectionHistory.set(requestId, {
+            routeName,
+            providerKey,
+            modelId,
+            createdAt: Date.now()
+        });
+        this.pruneStickyPlans();
+    }
+    buildStickyPlan(features, selection, target) {
+        const descriptor = this.resolveStickyDescriptor(selection.routeUsed, features);
+        if (!descriptor || descriptor.rounds <= 0) {
+            return null;
+        }
+        const plan = {
+            routeName: selection.routeUsed,
+            strategy: descriptor.strategy,
+            providerKey: descriptor.strategy === 'target' ? selection.providerKey : undefined,
+            modelId: descriptor.strategy === 'target' ? target.modelId : undefined,
+            remainingRounds: descriptor.rounds,
+            totalRounds: descriptor.rounds,
+            reason: descriptor.reason,
+            createdAt: Date.now()
+        };
+        return plan;
+    }
+    storeStickyPlan(requestId, plan) {
+        if (!requestId) {
+            return;
+        }
+        this.pruneStickyPlans();
+        if (plan && plan.remainingRounds > 0) {
+            this.stickyPlans.set(requestId, plan);
+        }
+        else {
+            this.stickyPlans.delete(requestId);
+        }
+    }
+    resolveStickyDescriptor(routeName, features) {
+        if (this.shouldForceApplyPatchSticky(features)) {
+            return { strategy: 'target', rounds: 1, reason: 'apply_patch' };
+        }
+        if (routeName === 'coding' || routeName === 'thinking') {
+            return { strategy: 'pool', rounds: 3, reason: routeName };
+        }
+        if (routeName === 'tools') {
+            return { strategy: 'pool', rounds: 0, reason: routeName };
+        }
+        if (routeName === DEFAULT_ROUTE || !routeName) {
+            return null;
+        }
+        return { strategy: 'pool', rounds: 1, reason: routeName };
+    }
+    maybeForceStickyFromHistory(prevId, features) {
+        if (!this.shouldForceApplyPatchSticky(features)) {
+            return null;
+        }
+        const snapshot = this.selectionHistory.get(prevId);
+        if (!snapshot) {
+            return null;
+        }
+        if (!this.healthManager.isAvailable(snapshot.providerKey)) {
+            return null;
+        }
+        return {
+            routeName: snapshot.routeName,
+            providerKey: snapshot.providerKey,
+            modelId: snapshot.modelId,
+            strategy: 'target',
+            remainingRounds: 0,
+            totalRounds: 1,
+            reason: 'apply_patch',
+            createdAt: Date.now(),
+            sourceRequestId: prevId,
+            mode: 'forced'
+        };
+    }
+    shouldForceApplyPatchSticky(features) {
+        const name = (features.lastAssistantToolName || '').toLowerCase();
+        if (name === 'apply_patch') {
+            return true;
+        }
+        const detail = (features.lastAssistantToolDetail || '').toLowerCase();
+        if (detail.includes('apply_patch')) {
+            return true;
+        }
+        return false;
+    }
+    extractPreviousRequestId(metadata) {
+        const resume = metadata.responsesResume;
+        if (resume && typeof resume.previousRequestId === 'string' && resume.previousRequestId.trim()) {
+            return resume.previousRequestId.trim();
+        }
+        return undefined;
+    }
+    pruneStickyPlans() {
+        const cutoff = Date.now() - STICKY_PLAN_TTL_MS;
+        for (const [key, plan] of this.stickyPlans.entries()) {
+            if (!plan || plan.createdAt < cutoff) {
+                this.stickyPlans.delete(key);
+            }
+        }
+        for (const [key, snapshot] of this.selectionHistory.entries()) {
+            if (!snapshot || snapshot.createdAt < cutoff) {
+                this.selectionHistory.delete(key);
+            }
+        }
+    }
+    buildErrorSignature(code, statusCode, message) {
+        const normalizedMessage = typeof message === 'string'
+            ? message.trim().toLowerCase().replace(/\s+/g, ' ').slice(0, 120)
+            : '';
+        const codeToken = code?.toUpperCase() || 'ERR_UNKNOWN';
+        const statusToken = typeof statusCode === 'number' ? String(statusCode) : 'NA';
+        return `${statusToken}|${codeToken}|${normalizedMessage}`;
+    }
+    bumpProviderErrorStreak(providerKey, signature) {
+        if (!providerKey || !signature) {
+            return 0;
+        }
+        const now = Date.now();
+        const entry = this.providerErrorStreaks.get(providerKey);
+        if (!entry || entry.signature !== signature || now - entry.lastAt > ERROR_STREAK_TTL_MS) {
+            this.providerErrorStreaks.set(providerKey, { signature, count: 1, lastAt: now });
+            return 1;
+        }
+        const next = { signature, count: entry.count + 1, lastAt: now };
+        this.providerErrorStreaks.set(providerKey, next);
+        return next.count;
+    }
+    resetProviderErrorStreak(providerKey) {
+        if (providerKey) {
+            this.providerErrorStreaks.delete(providerKey);
+        }
+    }
     validateConfig(config) {
         if (!config.routing || typeof config.routing !== 'object') {
             throw new VirtualRouterError('routing configuration is required', VirtualRouterErrorCode.CONFIG_ERROR);
@@ -121,7 +349,8 @@ export class VirtualRouterEngine {
         }
     }
     selectProvider(requestedRoute, metadata, classification) {
-        const candidates = this.buildRouteCandidates(requestedRoute, classification.candidates);
+        const normalizedRoute = this.normalizeRouteName(requestedRoute);
+        const candidates = this.buildRouteCandidates(normalizedRoute, classification.candidates);
         const stickyKey = this.resolveStickyKey(metadata);
         const attempted = [];
         for (const routeName of candidates) {
@@ -141,7 +370,8 @@ export class VirtualRouterEngine {
             }
             attempted.push(routeName);
         }
-        throw new VirtualRouterError(`All providers unavailable for route ${requestedRoute}`, VirtualRouterErrorCode.PROVIDER_NOT_AVAILABLE, { routeName: requestedRoute, attempted });
+        const failureRoute = attempted.length ? attempted[attempted.length - 1] : requestedRoute;
+        throw new VirtualRouterError(`All providers unavailable for route ${failureRoute}`, VirtualRouterErrorCode.PROVIDER_NOT_AVAILABLE, { routeName: failureRoute, attempted });
     }
     incrementRouteStat(routeName, providerKey) {
         if (!this.routeStats.has(routeName)) {
@@ -207,6 +437,13 @@ export class VirtualRouterEngine {
             cooldownOverrideMs = Math.max(10 * 60_000, this.providerHealthConfig().fatalCooldownMs ?? 10 * 60_000);
             reason = 'compatibility';
         }
+        const signature = this.buildErrorSignature(code, statusCode, event.message);
+        const streak = this.bumpProviderErrorStreak(providerKey, signature);
+        if (streak >= ERROR_STREAK_THRESHOLD) {
+            fatal = true;
+            reason = reason === 'unknown' ? 'repeated_error' : `${reason}|repeated`;
+            cooldownOverrideMs = Math.max(this.providerHealthConfig().fatalCooldownMs ?? 5 * 60_000, 5 * 60_000);
+        }
         return {
             providerKey,
             routeName,
@@ -270,6 +507,59 @@ export class VirtualRouterEngine {
         }
         return filtered.length ? filtered : [DEFAULT_ROUTE];
     }
+    ensureConfiguredClassification(classification) {
+        const normalizedRoute = this.normalizeRouteName(classification.routeName);
+        const normalizedCandidates = this.normalizeCandidateList(normalizedRoute, classification.candidates);
+        const fallback = normalizedRoute === DEFAULT_ROUTE ? true : classification.fallback;
+        return {
+            ...classification,
+            routeName: normalizedRoute,
+            fallback,
+            candidates: normalizedCandidates
+        };
+    }
+    normalizeCandidateList(primaryRoute, rawCandidates) {
+        const base = rawCandidates && rawCandidates.length ? rawCandidates : [primaryRoute];
+        const deduped = [];
+        for (const routeName of base) {
+            if (!routeName) {
+                continue;
+            }
+            if (!this.isRouteConfigured(routeName)) {
+                continue;
+            }
+            if (!deduped.includes(routeName)) {
+                deduped.push(routeName);
+            }
+        }
+        if (!deduped.includes(primaryRoute) && this.isRouteConfigured(primaryRoute)) {
+            deduped.push(primaryRoute);
+        }
+        if (!deduped.includes(DEFAULT_ROUTE) && this.isRouteConfigured(DEFAULT_ROUTE)) {
+            deduped.push(DEFAULT_ROUTE);
+        }
+        if (!deduped.length && this.isRouteConfigured(DEFAULT_ROUTE)) {
+            deduped.push(DEFAULT_ROUTE);
+        }
+        return this.sortByPriority(deduped);
+    }
+    normalizeRouteName(routeName) {
+        if (routeName && this.isRouteConfigured(routeName)) {
+            return routeName;
+        }
+        if (this.isRouteConfigured(DEFAULT_ROUTE)) {
+            return DEFAULT_ROUTE;
+        }
+        const firstConfigured = Object.keys(this.routing).find((key) => this.isRouteConfigured(key));
+        return firstConfigured || DEFAULT_ROUTE;
+    }
+    isRouteConfigured(routeName) {
+        if (!routeName) {
+            return false;
+        }
+        const pool = this.routing[routeName];
+        return Array.isArray(pool) && pool.length > 0;
+    }
     sortByPriority(routeNames) {
         return [...routeNames].sort((a, b) => this.routeWeight(a) - this.routeWeight(b));
     }
@@ -277,25 +567,89 @@ export class VirtualRouterEngine {
         const idx = ROUTE_PRIORITY.indexOf(routeName);
         return idx >= 0 ? idx : ROUTE_PRIORITY.length;
     }
-    buildHitReason(routeUsed, classification, features) {
+    buildHitReason(routeUsed, classification, features, sticky, phase) {
         const reasoning = classification.reasoning || '';
         const primary = reasoning.split('|')[0] || '';
         const lastToolName = features.lastAssistantToolName;
+        const lastToolDetail = features.lastAssistantToolDetail;
         if (routeUsed === 'tools') {
-            if (lastToolName) {
-                return primary ? `${primary}(${lastToolName})` : `tools(${lastToolName})`;
-            }
-            return primary || 'tools';
+            const decoratedTools = lastToolName ? this.formatToolIdentifier(lastToolName, lastToolDetail) : null;
+            const base = primary
+                ? decoratedTools
+                    ? `${primary}(${decoratedTools})`
+                    : primary
+                : decoratedTools
+                    ? `tools(${decoratedTools})`
+                    : 'tools';
+            return this.decorateReason(base, sticky, phase);
         }
         if (routeUsed === 'thinking') {
-            return primary || 'thinking';
+            return this.decorateReason(primary || 'thinking', sticky, phase);
         }
         if (routeUsed === DEFAULT_ROUTE && classification.fallback) {
-            return primary || 'fallback:default';
+            return this.decorateReason(primary || 'fallback:default', sticky, phase);
         }
         if (primary) {
-            return primary;
+            return this.decorateReason(primary, sticky, phase);
+        }
+        return this.decorateReason(routeUsed ? `route:${routeUsed}` : 'route:unknown', sticky, phase);
+    }
+    formatToolIdentifier(name, detail) {
+        if (!detail) {
+            return name;
+        }
+        return `${name}:${detail}`;
+    }
+    decorateReason(base, sticky, phase) {
+        let result = base;
+        if (sticky) {
+            result = `${result}|sticky:${sticky.reason}`;
+        }
+        if (phase === 'execution') {
+            result = `${result}|phase=execution`;
+        }
+        return result;
+    }
+    buildVirtualRouterHitLog(route, providerKey, modelId, reason, sticky, phase) {
+        const parts = ['[virtual-router-hit]', route, providerKey];
+        if (modelId) {
+            parts.push(modelId);
+        }
+        if (reason) {
+            parts.push(`reason=${reason}`);
+        }
+        parts.push(`phase=${phase}`);
+        if (sticky) {
+            const total = Math.max(1, sticky.totalRounds || sticky.remainingRounds || 1);
+            const consumed = Math.max(1, Math.min(total, total - sticky.remainingRounds));
+            const descriptor = `${sticky.strategy}:${sticky.reason}[${consumed}/${total};${sticky.mode}]`;
+            parts.push(`sticky=${descriptor}`);
+        }
+        const message = parts.filter((segment) => typeof segment === 'string' && segment.length > 0).join(' ');
+        return this.colorizeVirtualRouterLog(message);
+    }
+    colorizeVirtualRouterLog(message) {
+        if (!this.shouldColorVirtualRouterLogs()) {
+            return message;
+        }
+        return `${VIRTUAL_ROUTER_HIT_COLOR}${message}${ANSI_RESET}`;
+    }
+    shouldColorVirtualRouterLogs() {
+        if (typeof process === 'undefined') {
+            return false;
+        }
+        const noColor = String(process.env.NO_COLOR ?? process.env.RCC_NO_COLOR ?? '').toLowerCase();
+        if (noColor === '1' || noColor === 'true') {
+            return false;
+        }
+        const forceColor = String(process.env.FORCE_COLOR ?? '').trim();
+        if (forceColor === '0') {
+            return false;
+        }
+        const stdout = process.stdout;
+        if (stdout && stdout.isTTY === false) {
+            return false;
         }
-        return routeUsed ? `route:${routeUsed}` : 'route:unknown';
+        return true;
     }
 }

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

@@ -43,6 +43,8 @@ const WRITE_TOOL_KEYWORDS = ['write', 'patch', 'modify', 'edit', 'create', 'upda
 const SEARCH_TOOL_KEYWORDS = ['search', 'websearch', 'web_fetch', 'webfetch', 'web-request', 'web_request', 'internet'];
 const SHELL_TOOL_NAMES = new Set(['shell_command', 'shell', 'bash']);
 const SHELL_HEREDOC_PATTERN = /<<\s*['"]?[a-z0-9_-]+/i;
+const COMMAND_DETAIL_MAX_LENGTH = 80;
+const TOOL_CATEGORY_PRIORITY = ['search', 'write', 'read', 'other'];
 const SHELL_WRITE_PATTERNS = [
     'apply_patch',
     'sed -i',
@@ -134,7 +136,7 @@ export function buildRoutingFeatures(request, metadata) {
     const hasCodingTool = detectCodingTool(request);
     const hasWebTool = detectWebTool(request);
     const hasThinkingKeyword = hasThinking || detectExtendedThinkingKeyword(normalizedUserText);
-    const lastAssistantTool = detectLastAssistantToolCategory(assistantMessages);
+    const assistantToolSummary = summarizeAssistantToolUsage(assistantMessages);
     return {
         requestId: metadata.requestId,
         model: request.model,
@@ -149,8 +151,11 @@ export function buildRoutingFeatures(request, metadata) {
         hasCodingTool,
         hasThinkingKeyword,
         estimatedTokens,
-        lastAssistantToolCategory: lastAssistantTool?.category,
-        lastAssistantToolName: lastAssistantTool?.name,
+        lastAssistantToolCategory: assistantToolSummary.primary?.category,
+        lastAssistantToolName: assistantToolSummary.primary?.name,
+        lastAssistantToolDetail: assistantToolSummary.primary?.detail,
+        assistantToolCategories: assistantToolSummary.categories,
+        assistantCalledWebSearchTool: assistantToolSummary.usedWebSearchTool,
         metadata: {
             ...metadata
         }
@@ -294,30 +299,73 @@ function extractToolDescription(tool) {
     }
     return '';
 }
-function detectLastAssistantToolCategory(messages) {
+function summarizeAssistantToolUsage(messages) {
     for (let idx = messages.length - 1; idx >= 0; idx -= 1) {
         const msg = messages[idx];
         if (!msg || !Array.isArray(msg.tool_calls) || msg.tool_calls.length === 0) {
             continue;
         }
-        let fallback;
+        const classifications = [];
+        let usedWebSearchTool = false;
         for (const call of msg.tool_calls) {
             const classification = classifyToolCall(call);
-            if (!classification) {
-                continue;
-            }
-            if (!fallback) {
-                fallback = classification;
-            }
-            if (classification.category !== 'other') {
-                return classification;
+            if (classification) {
+                classifications.push(classification);
+                if (classification.category === 'search' && isWebSearchToolInvocation(classification)) {
+                    usedWebSearchTool = true;
+                }
             }
         }
-        if (fallback) {
-            return fallback;
+        if (!classifications.length) {
+            continue;
+        }
+        const categorySet = new Set();
+        for (const classification of classifications) {
+            categorySet.add(classification.category);
+        }
+        const categories = orderToolCategories(Array.from(categorySet));
+        const primary = classifications.find((classification) => classification.category !== 'other') ?? classifications[0];
+        return {
+            categories,
+            primary,
+            usedWebSearchTool
+        };
+    }
+    return { categories: [], usedWebSearchTool: false };
+}
+function orderToolCategories(categories) {
+    const ordered = [];
+    for (const category of TOOL_CATEGORY_PRIORITY) {
+        if (categories.includes(category)) {
+            ordered.push(category);
         }
     }
-    return undefined;
+    for (const category of categories) {
+        if (!ordered.includes(category)) {
+            ordered.push(category);
+        }
+    }
+    return ordered;
+}
+function isWebSearchToolName(name) {
+    const normalized = name.toLowerCase();
+    if (SEARCH_TOOL_EXACT.has(normalized)) {
+        return true;
+    }
+    return WEB_TOOL_KEYWORDS.some((keyword) => normalized.includes(keyword.toLowerCase()));
+}
+function isWebSearchToolInvocation(classification) {
+    if (!classification) {
+        return false;
+    }
+    if (isWebSearchToolName(classification.name)) {
+        return true;
+    }
+    if (classification.detail) {
+        const detail = classification.detail.toLowerCase();
+        return WEB_TOOL_KEYWORDS.some((keyword) => detail.includes(keyword.toLowerCase()));
+    }
+    return false;
 }
 function classifyToolCall(call) {
     if (!call || typeof call !== 'object') {
@@ -330,14 +378,19 @@ function classifyToolCall(call) {
         return undefined;
     }
     const argsObject = parseToolArguments(call?.function?.arguments);
-    const commandText = extractCommandText(argsObject);
+    const commandText = extractCommandText(argsObject).trim();
+    const commandDetail = summarizeCommandDetail(commandText);
     const nameCategory = categorizeToolName(functionName);
     if (nameCategory === 'write' || nameCategory === 'read' || nameCategory === 'search') {
         return { category: nameCategory, name: functionName };
     }
     if (SHELL_TOOL_NAMES.has(functionName)) {
         const shellCategory = classifyShellCommand(commandText);
-        return { category: shellCategory, name: functionName };
+        return {
+            category: shellCategory,
+            name: functionName,
+            detail: commandDetail
+        };
     }
     if (commandText) {
         const derivedCategory = classifyShellCommand(commandText);
@@ -380,7 +433,12 @@ function extractCommandText(args) {
         return args;
     }
     if (Array.isArray(args)) {
-        return args.map((item) => (typeof item === 'string' ? item : '')).filter(Boolean).join(' ');
+        const tokens = collectCommandTokens(args);
+        if (tokens.length) {
+            return tokens.join(' ');
+        }
+        const derived = extractFirstStringValue(args);
+        return derived ?? '';
     }
     if (typeof args === 'object') {
         const record = args;
@@ -391,7 +449,20 @@ function extractCommandText(args) {
             return command;
         }
         if (Array.isArray(command)) {
-            return command.map((item) => (typeof item === 'string' ? item : '')).filter(Boolean).join(' ');
+            const tokens = collectCommandTokens(command);
+            if (tokens.length) {
+                return tokens.join(' ');
+            }
+            const derivedCommand = extractFirstStringValue(command);
+            if (derivedCommand) {
+                return derivedCommand;
+            }
+        }
+        if (command && typeof command === 'object') {
+            const derivedCommand = extractFirstStringValue(command);
+            if (derivedCommand) {
+                return derivedCommand;
+            }
         }
         if (typeof input === 'string') {
             return input;
@@ -400,7 +471,30 @@ function extractCommandText(args) {
             return nestedArgs;
         }
         if (Array.isArray(nestedArgs)) {
-            return nestedArgs.map((item) => (typeof item === 'string' ? item : '')).filter(Boolean).join(' ');
+            const tokens = collectCommandTokens(nestedArgs);
+            if (tokens.length) {
+                return tokens.join(' ');
+            }
+            const derivedArgs = extractFirstStringValue(nestedArgs);
+            if (derivedArgs) {
+                return derivedArgs;
+            }
+        }
+        if (nestedArgs && typeof nestedArgs === 'object') {
+            const derivedArgs = extractFirstStringValue(nestedArgs);
+            if (derivedArgs) {
+                return derivedArgs;
+            }
+        }
+        const fallback = extractFirstStringValue(record);
+        if (fallback) {
+            return fallback;
+        }
+        try {
+            return JSON.stringify(record);
+        }
+        catch {
+            return '';
         }
     }
     return '';
@@ -489,3 +583,71 @@ function trimEnclosingQuotes(value) {
     }
     return value;
 }
+function summarizeCommandDetail(command) {
+    if (!command) {
+        return undefined;
+    }
+    const [firstSegment] = splitCommandSegments(command);
+    const candidate = firstSegment ?? command;
+    const normalized = candidate.replace(/\s+/g, ' ').trim();
+    if (!normalized) {
+        return undefined;
+    }
+    if (normalized.length > COMMAND_DETAIL_MAX_LENGTH) {
+        return `${normalized.slice(0, COMMAND_DETAIL_MAX_LENGTH - 1)}…`;
+    }
+    return normalized;
+}
+function collectCommandTokens(values) {
+    const tokens = [];
+    for (const value of values) {
+        if (typeof value === 'string') {
+            const trimmed = value.trim();
+            if (trimmed) {
+                tokens.push(trimmed);
+            }
+            continue;
+        }
+        if (Array.isArray(value)) {
+            const nested = collectCommandTokens(value);
+            if (nested.length) {
+                tokens.push(nested.join(' '));
+                continue;
+            }
+        }
+        if (value && typeof value === 'object') {
+            const extracted = extractFirstStringValue(value);
+            if (extracted) {
+                tokens.push(extracted.trim());
+            }
+        }
+    }
+    return tokens.filter(Boolean).slice(0, 16);
+}
+function extractFirstStringValue(value) {
+    if (!value) {
+        return undefined;
+    }
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        return trimmed || undefined;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const extracted = extractFirstStringValue(item);
+            if (extracted) {
+                return extracted;
+            }
+        }
+        return undefined;
+    }
+    if (typeof value === 'object') {
+        for (const candidate of Object.values(value)) {
+            const extracted = extractFirstStringValue(candidate);
+            if (extracted) {
+                return extracted;
+            }
+        }
+    }
+    return undefined;
+}

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

@@ -118,6 +118,9 @@ export interface RoutingFeatures {
     estimatedTokens: number;
     lastAssistantToolCategory?: 'read' | 'write' | 'search' | 'other';
     lastAssistantToolName?: string;
+    lastAssistantToolDetail?: string;
+    assistantToolCategories?: Array<'read' | 'write' | 'search' | 'other'>;
+    assistantCalledWebSearchTool?: boolean;
     metadata: RouterMetadataInput;
 }
 export interface ClassificationResult {
@@ -145,8 +148,11 @@ export interface TargetMetadata {
     processMode?: 'chat' | 'passthrough';
     responsesConfig?: ResponsesProviderConfig;
 }
+export type ResponsesStreamingMode = 'auto' | 'always' | 'never';
 export interface ResponsesProviderConfig {
     toolCallIdStyle?: 'fc' | 'preserve';
+    streaming?: ResponsesStreamingMode;
+    instructionsMode?: 'default' | 'inline';
 }
 export declare enum VirtualRouterErrorCode {
     NO_STANDARDIZED_REQUEST = "NO_STANDARDIZED_REQUEST",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsonstudio/llms",
-  "version": "0.6.104",
+  "version": "0.6.141",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",