@jsonstudio/llms 0.6.1892 → 0.6.2172

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

@@ -1,10 +1,51 @@
 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;
+    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: {
+    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;
@@ -16,5 +57,5 @@ export declare function describeTargetProvider(providerKey: string, fallbackMode
     resolvedModel?: string;
 };
 export declare function buildHitReason(routeUsed: string, providerKey: string, classification: ClassificationResult, features: RoutingFeatures, mode: RoutingInstructionMode | undefined, deps: LoggingDeps): string;
-export declare function formatVirtualRouterHit(routeName: string, poolId: string | undefined, providerKey: string, modelId?: string, hitReason?: string, stickyScope?: string, routingState?: RoutingInstructionState): string;
+export declare function formatVirtualRouterHit(record: VirtualRouterHitRecord): string;
 export {};

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

@@ -1,4 +1,5 @@
 import { DEFAULT_MODEL_CONTEXT_TOKENS, DEFAULT_ROUTE } from './types.js';
+const DEFAULT_STOP_MESSAGE_MAX_REPEATS = 10;
 function summarizeStopMessageRuntime(state) {
     if (!state) {
         return {
@@ -14,9 +15,14 @@ function summarizeStopMessageRuntime(state) {
     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 maxRepeats = typeof state.stopMessageMaxRepeats === 'number' && Number.isFinite(state.stopMessageMaxRepeats)
+    const parsedMaxRepeats = typeof state.stopMessageMaxRepeats === 'number' && Number.isFinite(state.stopMessageMaxRepeats)
         ? Math.max(0, Math.floor(state.stopMessageMaxRepeats))
         : 0;
+    const maxRepeats = parsedMaxRepeats > 0
+        ? parsedMaxRepeats
+        : 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;
@@ -41,6 +47,55 @@ function summarizeStopMessageRuntime(state) {
         ...(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(),
+        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;
@@ -175,9 +230,9 @@ export function buildHitReason(routeUsed, providerKey, classification, features,
     }
     return base;
 }
-export function formatVirtualRouterHit(routeName, poolId, providerKey, modelId, hitReason, stickyScope, routingState) {
+export function formatVirtualRouterHit(record) {
     try {
-        const now = new Date();
+        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');
@@ -186,18 +241,24 @@ export function formatVirtualRouterHit(routeName, poolId, providerKey, modelId,
         const reset = '\x1b[0m';
         const timeColor = '\x1b[90m';
         const stickyColor = '\x1b[33m';
-        const routeColor = resolveRouteColor(routeName);
+        const routeColor = resolveRouteColor(record.routeName);
         const stopColor = '\x1b[38;5;214m';
         const prefix = `${prefixColor}[virtual-router-hit]${reset}`;
         const timeLabel = `${timeColor}${timestamp}${reset}`;
-        const { providerLabel, resolvedModel } = describeTargetProvider(providerKey, modelId);
-        const routeLabel = poolId ? `${routeName}/${poolId}` : routeName;
+        const { providerLabel, resolvedModel } = describeTargetProvider(record.providerKey, record.modelId);
+        const routeLabel = record.poolId ? `${record.routeName}/${record.poolId}` : record.routeName;
         const targetLabel = `${routeLabel} -> ${providerLabel}${resolvedModel ? '.' + resolvedModel : ''}`;
-        const stickyText = formatStickyScope(stickyScope);
+        const stickyText = formatStickyScope(record.stickyScope);
         const stickyLabel = stickyText ? ` ${stickyColor}[sticky:${stickyText}]${reset}` : '';
-        const reasonLabel = hitReason ? ` reason=${hitReason}` : '';
+        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 = summarizeStopMessageRuntime(routingState);
+        const stop = record.stopMessage;
         if (stop.hasAny) {
             const parts = [
                 stop.safeText ? `"${stop.safeText}"` : '"(mode-only)"',
@@ -214,22 +275,28 @@ export function formatVirtualRouterHit(routeName, poolId, providerKey, modelId,
             }
             stopLabel = ` ${stopColor}[stopMessage:${parts.join(' ')}]${reset}`;
         }
-        return `${prefix} ${timeLabel} ${routeColor}${targetLabel}${stickyLabel}${reasonLabel}${stopLabel}${reset}`;
+        return `${prefix} ${timeLabel} ${routeColor}${targetLabel}${stickyLabel}${reasonLabel}${requestTokenLabel}${penaltyLabel}${stopLabel}${reset}`;
     }
     catch {
-        const now = new Date();
+        const now = new Date(record.timestampMs);
         const timestamp = now.toLocaleTimeString('zh-CN', { hour12: false });
-        const routeLabel = poolId ? `${routeName}/${poolId}` : routeName;
-        const stickyText = formatStickyScope(stickyScope);
+        const routeLabel = record.poolId ? `${record.routeName}/${record.poolId}` : record.routeName;
+        const stickyText = formatStickyScope(record.stickyScope);
         const stickyLabel = stickyText ? ` [sticky:${stickyText}]` : '';
+        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 = summarizeStopMessageRuntime(routingState);
+        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} ${routeLabel} -> ${providerKey}${modelId ? '.' + modelId : ''}${stickyLabel}${hitReason ? ` reason=${hitReason}` : ''}${stopLabel}`;
+        return `[virtual-router-hit] ${timestamp} ${routeLabel} -> ${record.providerKey}${record.modelId ? '.' + record.modelId : ''}${stickyLabel}${record.hitReason ? ` reason=${record.hitReason}` : ''}${requestTokenLabel}${penaltyLabel}${stopLabel}`;
     }
 }

package/dist/router/virtual-router/engine-selection/multimodal-capability.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderRegistry } from '../provider-registry.js';
+import type { RoutingFeatures } from '../types.js';
+export declare function providerSupportsMultimodalRequest(providerKey: string, features: RoutingFeatures, providerRegistry: ProviderRegistry): boolean;

package/dist/router/virtual-router/engine-selection/multimodal-capability.js

@@ -0,0 +1,26 @@
+import { extractProviderId, getProviderModelId } from './key-parsing.js';
+function isQwen35PlusProvider(providerKey, providerRegistry) {
+    const providerId = (extractProviderId(providerKey) ?? '').trim().toLowerCase();
+    if (providerId !== 'qwen') {
+        return false;
+    }
+    const modelId = (getProviderModelId(providerKey, providerRegistry) ?? '').trim().toLowerCase();
+    if (!modelId) {
+        return false;
+    }
+    return modelId === 'qwen3.5-plus' || modelId === 'qwen3-5-plus' || modelId === 'qwen3_5-plus';
+}
+export function providerSupportsMultimodalRequest(providerKey, features, providerRegistry) {
+    if (!features.hasImageAttachment) {
+        return true;
+    }
+    if (!isQwen35PlusProvider(providerKey, providerRegistry)) {
+        return true;
+    }
+    if (features.hasVideoAttachment !== true) {
+        return true;
+    }
+    const hasRemoteVideo = features.hasRemoteVideoAttachment === true;
+    const hasLocalVideo = features.hasLocalVideoAttachment === true;
+    return hasRemoteVideo && !hasLocalVideo;
+}

package/dist/router/virtual-router/engine-selection/route-utils.js

@@ -43,6 +43,10 @@ export function buildRouteCandidates(requestedRoute, classificationCandidates, f
     const forceVision = routeHasForceFlag('vision', routing);
     const hasMultimodalTargets = routeHasTargets(routing.multimodal);
     const hasVisionTargets = routeHasTargets(routing.vision);
+    const hasLocalVideoAttachment = features.hasVideoAttachment === true && features.hasLocalVideoAttachment === true;
+    if (features.hasImageAttachment && hasLocalVideoAttachment && hasVisionTargets) {
+        return ['vision'];
+    }
     const normalized = normalizeRouteAlias(requestedRoute || DEFAULT_ROUTE);
     const baseList = [];
     if (classificationCandidates && classificationCandidates.length) {
@@ -59,9 +63,9 @@ export function buildRouteCandidates(requestedRoute, classificationCandidates, f
                 baseList.unshift('multimodal');
             }
         }
-        else if (hasVisionTargets) {
+        if (hasVisionTargets) {
             if (!baseList.includes('vision')) {
-                baseList.unshift('vision');
+                baseList.push('vision');
             }
         }
         if (!forceVision && hasMultimodalTargets) {

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

@@ -10,6 +10,7 @@ export type SelectionDeps = {
     contextAdvisor: ContextAdvisor;
     loadBalancer: RouteLoadBalancer;
     isProviderCoolingDown: (providerKey: string) => boolean;
+    getProviderCooldownRemainingMs?: (providerKey: string) => number;
     resolveStickyKey: (metadata: RouterMetadataInput) => string | undefined;
     quotaView?: ProviderQuotaView;
     aliasQueueStore?: Map<string, string[]>;

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

@@ -3,6 +3,7 @@ import { resolveContextWeightedConfig } from '../context-weighted.js';
 import { resolveHealthWeightedConfig } from '../health-weighted.js';
 import { pinCandidatesByAliasQueue, resolveAliasSelectionStrategy } from './alias-selection.js';
 import { extractKeyAlias, extractKeyIndex, extractProviderId, getProviderModelId } from './key-parsing.js';
+import { providerSupportsMultimodalRequest } from './multimodal-capability.js';
 import { selectProviderKeyFromCandidatePool } from './tier-selection-select.js';
 import { lookupAntigravityPinnedAliasForSessionId, unpinAntigravitySessionAliasForSessionId } from '../../../conversion/compat/antigravity-session-signature.js';
 const DEFAULT_ANTIGRAVITY_ALIAS_SESSION_COOLDOWN_MS = 5 * 60_000;
@@ -190,6 +191,9 @@ function applyAntigravityAliasSessionLeases(targets, deps, metadata) {
     const strictBinding = strictRequested && Boolean(pinnedLeaseKey);
     const geminiSessionKey = buildScopedSessionKey(sessionKey);
     let preferredGeminiRuntimeKey = pinnedLeaseKey || sessionAliasStore.get(geminiSessionKey);
+    if (preferredGeminiRuntimeKey && !preferredGeminiRuntimeKey.includes('::')) {
+        preferredGeminiRuntimeKey = buildAntigravityLeaseRuntimeKey(preferredGeminiRuntimeKey);
+    }
     if (preferredGeminiRuntimeKey && !pinnedLeaseKey) {
         const lease = leaseStore.get(preferredGeminiRuntimeKey);
         if (lease && lease.sessionKey !== geminiSessionKey && now - lease.lastSeenAt < cooldownMs) {
@@ -264,7 +268,7 @@ function applyAntigravityAliasSessionLeases(targets, deps, metadata) {
         blocked += 1;
         return false;
     });
-    return { targets: filtered, blocked, preferredPinned, pinnedStrict };
+    return { targets: filtered, blocked, preferredPinned, pinnedStrict, preferredRuntimeKey: preferredGeminiRuntimeKey };
 }
 export function trySelectFromTier(routeName, tier, stickyKey, estimatedTokens, features, deps, options) {
     const { disabledProviders, disabledKeysMap, allowedProviders, disabledModels, requiredProviderKeys } = options;
@@ -385,6 +389,7 @@ export function trySelectFromTier(routeName, tier, stickyKey, estimatedTokens, f
         targets = filtered;
     }
     if (features.hasImageAttachment && routeName === 'multimodal') {
+        targets = targets.filter((key) => providerSupportsMultimodalRequest(key, features, deps.providerRegistry));
         const kimiTargets = targets.filter((key) => {
             const modelId = getProviderModelId(key, deps.providerRegistry) ?? '';
             return modelId.trim().toLowerCase() === 'kimi-k2.5';
@@ -448,6 +453,31 @@ export function trySelectFromTier(routeName, tier, stickyKey, estimatedTokens, f
         const candidatesForSelect = avoidAntigravityOnRetry
             ? preferNonAntigravityWhenPossible(candidatePool)
             : candidatePool;
+        if (leaseResult.preferredRuntimeKey && !leaseResult.pinnedStrict) {
+            const preferredCandidates = candidatesForSelect.filter((key) => isAntigravityGeminiModelKey(key, deps) && extractLeaseRuntimeKey(key, deps) === leaseResult.preferredRuntimeKey);
+            if (preferredCandidates.length > 0) {
+                const preferredProviderKey = selectProviderKeyFromCandidatePool({
+                    routeName,
+                    tier,
+                    stickyKey,
+                    candidates: preferredCandidates,
+                    isSafePool,
+                    deps,
+                    options,
+                    contextResult,
+                    warnRatio,
+                    excludedKeys,
+                    isRecoveryAttempt,
+                    now,
+                    nowForWeights,
+                    healthWeightedCfg,
+                    contextWeightedCfg
+                });
+                if (preferredProviderKey) {
+                    return { providerKey: preferredProviderKey, poolTargets: tier.targets, tierId: tier.id };
+                }
+            }
+        }
         const providerKey = selectProviderKeyFromCandidatePool({
             routeName,
             tier,

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

@@ -11,16 +11,14 @@ export declare class VirtualRouterEngine {
     private routing;
     private readonly providerRegistry;
     private readonly healthManager;
-    private readonly providerCooldowns;
+    private get providerCooldowns();
     private loadBalancer;
     private classifier;
     private readonly contextAdvisor;
     private contextRouting;
-    private routeStats;
-    private readonly aliasQueueStore;
-    private readonly antigravityAliasLeaseStore;
-    private readonly antigravitySessionAliasStore;
-    private antigravityAliasReuseCooldownMs;
+    private readonly routeAnalytics;
+    private stickySessionManager;
+    private cooldownManager;
     private antigravityLeasePersistence;
     private readonly debug;
     private healthConfig;
@@ -30,6 +28,11 @@ export declare class VirtualRouterEngine {
     private routingStateStore;
     private routingInstructionState;
     private quotaView?;
+    /**
+     * Backward-compatible test/debug surface used by existing regression scripts.
+     * Keep this as a read-only view over StickySessionManager storage.
+     */
+    get antigravitySessionAliasStore(): Map<string, string>;
     constructor(deps?: {
         healthStore?: VirtualRouterHealthStore;
         routingStateStore?: RoutingInstructionStateStore;
@@ -41,6 +44,7 @@ export declare class VirtualRouterEngine {
         quotaView?: ProviderQuotaView | null;
     }): void;
     private parseDirectProviderModel;
+    private shouldFallbackDirectModelForMedia;
     initialize(config: VirtualRouterConfig): void;
     route(request: StandardizedRequest | ProcessedRequest, metadata: RouterMetadataInput): {
         target: TargetMetadata;
@@ -57,6 +61,15 @@ export declare class VirtualRouterEngine {
             providers: string[];
             hits: number;
             lastUsedProvider?: string;
+            lastHit?: {
+                timestampMs: number;
+                reason?: string;
+                requestTokens?: number;
+                selectionPenalty?: number;
+                stopMessageActive: boolean;
+                stopMessageMode?: "on" | "off" | "auto";
+                stopMessageRemaining?: number;
+            };
         }>;
         health: import("./types.js").ProviderHealthState[];
     };
@@ -67,7 +80,7 @@ export declare class VirtualRouterEngine {
     private normalizeRouteAlias;
     private validateConfig;
     private selectProvider;
-    private incrementRouteStat;
+    private resolveSelectionPenalty;
     private providerHealthConfig;
     private resolveStickyKey;
     private resolveSessionScope;
@@ -105,6 +118,7 @@ export declare class VirtualRouterEngine {
     private markProviderCooldown;
     private clearProviderCooldown;
     private isProviderCoolingDown;
+    private getProviderCooldownRemainingMs;
     private restoreHealthFromStore;
     private buildHealthSnapshot;
     private persistHealthSnapshot;