@jsonstudio/llms 0.6.2172 → 0.6.3214

package/dist/router/virtual-router/engine-legacy/state-accessors.js

@@ -0,0 +1,118 @@
+import { resolveStopMessageScope, getRoutingInstructionState, persistRoutingInstructionState } from '../engine/routing-state/store.js';
+import { hasClientInjectScopedFields, stripClientInjectScopedFields } from './helpers.js';
+import { flattenPoolTargets } from './route-utils.js';
+export function getStopMessageState(engine, metadata) {
+    const hasArmedStopState = (candidate) => {
+        if (!candidate) {
+            return false;
+        }
+        const text = typeof candidate.stopMessageText === 'string' ? candidate.stopMessageText.trim() : '';
+        const maxRepeats = typeof candidate.stopMessageMaxRepeats === 'number' && Number.isFinite(candidate.stopMessageMaxRepeats)
+            ? Math.max(1, Math.floor(candidate.stopMessageMaxRepeats))
+            : 0;
+        const mode = typeof candidate.stopMessageStageMode === 'string'
+            ? candidate.stopMessageStageMode.trim().toLowerCase()
+            : '';
+        if (mode === 'off') {
+            return false;
+        }
+        return Boolean(text) && maxRepeats > 0;
+    };
+    const stopMessageScope = resolveStopMessageScope(metadata);
+    if (!stopMessageScope) {
+        const sessionScope = engine.resolveSessionScope(metadata);
+        if (sessionScope) {
+            const legacyState = getRoutingInstructionState(sessionScope, engine.routingInstructionState, engine.routingStateStore);
+            if (hasClientInjectScopedFields(legacyState)) {
+                const cleared = stripClientInjectScopedFields(legacyState);
+                engine.routingInstructionState.set(sessionScope, cleared);
+                persistRoutingInstructionState(sessionScope, cleared, engine.routingStateStore);
+            }
+        }
+        return null;
+    }
+    const effectiveState = getRoutingInstructionState(stopMessageScope, engine.routingInstructionState, engine.routingStateStore);
+    if (!hasArmedStopState(effectiveState)) {
+        return null;
+    }
+    const text = typeof effectiveState.stopMessageText === 'string' ? effectiveState.stopMessageText.trim() : '';
+    const maxRepeats = typeof effectiveState.stopMessageMaxRepeats === 'number' && Number.isFinite(effectiveState.stopMessageMaxRepeats)
+        ? Math.max(1, Math.floor(effectiveState.stopMessageMaxRepeats))
+        : 0;
+    const stageModeRaw = typeof effectiveState.stopMessageStageMode === 'string'
+        ? effectiveState.stopMessageStageMode.trim().toLowerCase()
+        : '';
+    const stageModeNormalized = stageModeRaw === 'on' || stageModeRaw === 'off' || stageModeRaw === 'auto'
+        ? stageModeRaw
+        : undefined;
+    const aiModeRaw = typeof effectiveState.stopMessageAiMode === 'string'
+        ? effectiveState.stopMessageAiMode.trim().toLowerCase()
+        : '';
+    const aiModeNormalized = aiModeRaw === 'on' || aiModeRaw === 'off' ? aiModeRaw : undefined;
+    if (stageModeNormalized === 'off' || !text || maxRepeats <= 0) {
+        return null;
+    }
+    return {
+        ...(text ? { stopMessageText: text } : {}),
+        stopMessageMaxRepeats: maxRepeats,
+        ...(typeof effectiveState.stopMessageSource === 'string' && effectiveState.stopMessageSource.trim()
+            ? { stopMessageSource: effectiveState.stopMessageSource.trim() }
+            : {}),
+        ...(typeof effectiveState.stopMessageUsed === 'number' && Number.isFinite(effectiveState.stopMessageUsed)
+            ? { stopMessageUsed: Math.max(0, Math.floor(effectiveState.stopMessageUsed)) }
+            : {}),
+        ...(typeof effectiveState.stopMessageUpdatedAt === 'number' && Number.isFinite(effectiveState.stopMessageUpdatedAt)
+            ? { stopMessageUpdatedAt: effectiveState.stopMessageUpdatedAt }
+            : {}),
+        ...(typeof effectiveState.stopMessageLastUsedAt === 'number' && Number.isFinite(effectiveState.stopMessageLastUsedAt)
+            ? { stopMessageLastUsedAt: effectiveState.stopMessageLastUsedAt }
+            : {}),
+        ...(stageModeNormalized ? { stopMessageStageMode: stageModeNormalized } : {}),
+        ...(aiModeNormalized ? { stopMessageAiMode: aiModeNormalized } : {}),
+        ...(typeof effectiveState.stopMessageAiSeedPrompt === 'string' && effectiveState.stopMessageAiSeedPrompt.trim()
+            ? { stopMessageAiSeedPrompt: effectiveState.stopMessageAiSeedPrompt.trim() }
+            : {}),
+        ...(Array.isArray(effectiveState.stopMessageAiHistory)
+            ? { stopMessageAiHistory: effectiveState.stopMessageAiHistory }
+            : {})
+    };
+}
+export function getPreCommandState(engine, metadata) {
+    const stopMessageScope = resolveStopMessageScope(metadata);
+    if (!stopMessageScope) {
+        return null;
+    }
+    const effectiveState = getRoutingInstructionState(stopMessageScope, engine.routingInstructionState, engine.routingStateStore);
+    if (!effectiveState) {
+        return null;
+    }
+    const scriptPath = typeof effectiveState.preCommandScriptPath === 'string' ? effectiveState.preCommandScriptPath.trim() : '';
+    if (!scriptPath) {
+        return null;
+    }
+    return {
+        preCommandScriptPath: scriptPath,
+        ...(typeof effectiveState.preCommandSource === 'string' && effectiveState.preCommandSource.trim()
+            ? { preCommandSource: effectiveState.preCommandSource.trim() }
+            : {}),
+        ...(typeof effectiveState.preCommandUpdatedAt === 'number' && Number.isFinite(effectiveState.preCommandUpdatedAt)
+            ? { preCommandUpdatedAt: effectiveState.preCommandUpdatedAt }
+            : {})
+    };
+}
+export function getStatus(engine) {
+    const routes = {};
+    for (const [route, pools] of Object.entries(engine.routing)) {
+        const stats = engine.routeAnalytics.getRouteStats(route);
+        routes[route] = {
+            providers: flattenPoolTargets(engine, pools),
+            hits: stats?.hits ?? 0,
+            lastUsedProvider: stats?.lastProvider,
+            ...(stats?.lastHit ? { lastHit: { ...stats.lastHit } } : {})
+        };
+    }
+    return {
+        routes,
+        health: engine.healthManager.getSnapshot()
+    };
+}

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

@@ -0,0 +1,123 @@
+import { ProviderHealthManager } from './health-manager.js';
+import { ProviderRegistry } from './provider-registry.js';
+import { RouteLoadBalancer } from './load-balancer.js';
+import { RoutingClassifier } from './classifier.js';
+import { ContextAdvisor } from './context-advisor.js';
+import type { ProcessedRequest, StandardizedRequest } from '../../conversion/hub/types/standardized.js';
+import { type RoutingPools, type RoutingDecision, type RoutingDiagnostics, type StopMessageStateSnapshot, type PreCommandStateSnapshot, type RoutePoolTier, type RouterMetadataInput, type RoutingFeatures, type VirtualRouterConfig, type VirtualRouterContextRoutingConfig, type TargetMetadata, type ProviderFailureEvent, type ProviderErrorEvent, type ProviderSuccessEvent, type VirtualRouterHealthStore } from './types.js';
+import type { RoutingInstructionState } from './routing-instructions.js';
+import type { ProviderQuotaView } from './types.js';
+import type { RoutingInstructionStateStoreLike } from './engine/routing-state/store.js';
+import { RouteAnalytics } from './engine/route-analytics.js';
+import { StickySessionManager } from './engine/sticky-session-manager.js';
+import { CooldownManager } from './engine/cooldown-manager.js';
+import { getStatus as getStatusImpl } from './engine-legacy/state-accessors.js';
+export declare class VirtualRouterEngine {
+    routing: RoutingPools;
+    readonly providerRegistry: ProviderRegistry;
+    readonly healthManager: ProviderHealthManager;
+    loadBalancer: RouteLoadBalancer;
+    classifier: RoutingClassifier;
+    readonly contextAdvisor: ContextAdvisor;
+    contextRouting: VirtualRouterContextRoutingConfig | undefined;
+    readonly routeAnalytics: RouteAnalytics;
+    stickySessionManager: StickySessionManager;
+    cooldownManager: CooldownManager;
+    antigravityLeasePersistence: {
+        loadedOnce: boolean;
+        loadedMtimeMs: number | null;
+        flushTimer: ReturnType<typeof setTimeout> | null;
+    };
+    readonly debug: Console;
+    healthConfig: VirtualRouterConfig['health'] | null;
+    readonly statsCenter: import("../../index.js").StatsCenter;
+    webSearchForce: boolean;
+    healthStore?: VirtualRouterHealthStore;
+    routingStateStore: RoutingInstructionStateStoreLike;
+    routingInstructionState: Map<string, RoutingInstructionState>;
+    quotaView?: ProviderQuotaView;
+    /**
+     * 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?: RoutingInstructionStateStoreLike;
+        quotaView?: ProviderQuotaView;
+    });
+    updateDeps(deps: {
+        healthStore?: VirtualRouterHealthStore | null;
+        routingStateStore?: RoutingInstructionStateStoreLike | null;
+        quotaView?: ProviderQuotaView | null;
+    }): void;
+    initialize(config: VirtualRouterConfig): void;
+    route(request: StandardizedRequest | ProcessedRequest, metadata: RouterMetadataInput): {
+        target: TargetMetadata;
+        decision: RoutingDecision;
+        diagnostics: RoutingDiagnostics;
+    };
+    getStopMessageState(metadata: RouterMetadataInput): StopMessageStateSnapshot | null;
+    getPreCommandState(metadata: RouterMetadataInput): PreCommandStateSnapshot | null;
+    handleProviderFailure(event: ProviderFailureEvent): void;
+    handleProviderError(event: ProviderErrorEvent): void;
+    handleProviderSuccess(event: ProviderSuccessEvent): void;
+    getStatus(): ReturnType<typeof getStatusImpl>;
+    normalizeRouteAlias(routeName: string | undefined): string;
+    buildRouteCandidates(requestedRoute: string, classificationCandidates: string[] | undefined, features: RoutingFeatures): string[];
+    reorderForInlineVision(routeNames: string[]): string[];
+    reorderForPreferredModel(routeNames: string[], modelId: string): string[];
+    routeSupportsModel(routeName: string, modelId: string): boolean;
+    routeSupportsInlineVision(routeName: string): boolean;
+    sortByPriority(routeNames: string[]): string[];
+    routeWeight(routeName: string): number;
+    routeHasForceFlag(routeName: string): boolean;
+    routeHasTargets(pools?: RoutePoolTier[]): boolean;
+    hasPrimaryPool(pools?: RoutePoolTier[]): boolean;
+    sortRoutePools(pools?: RoutePoolTier[]): RoutePoolTier[];
+    flattenPoolTargets(pools?: RoutePoolTier[]): string[];
+    markProviderCooldown(providerKey: string, cooldownMs: number | undefined): void;
+    clearProviderCooldown(providerKey: string): void;
+    isProviderCoolingDown(providerKey: string): boolean;
+    getProviderCooldownRemainingMs(providerKey: string): number;
+    restoreHealthFromStore(): void;
+    buildHealthSnapshot(): import("./types.js").VirtualRouterHealthSnapshot;
+    persistHealthSnapshot(): void;
+    parseDirectProviderModel(model: string | undefined): {
+        providerId: string;
+        modelId: string;
+    } | null;
+    shouldFallbackDirectModelForMedia(direct: {
+        providerId: string;
+        modelId: string;
+    }, features: RoutingFeatures): boolean;
+    selectProvider(requestedRoute: string, metadata: RouterMetadataInput, classification: any, features: RoutingFeatures, routingState?: RoutingInstructionState): {
+        providerKey: string;
+        routeUsed: string;
+        pool: string[];
+        poolId?: string;
+    };
+    selectFromCandidates(routes: string[], metadata: RouterMetadataInput, classification: any, features: RoutingFeatures, state: RoutingInstructionState, requiredProviderKeys?: Set<string>, allowAliasRotation?: boolean): {
+        providerKey: string;
+        routeUsed: string;
+        pool: string[];
+        poolId?: string;
+    };
+    selectFromStickyPool(stickyKeySet: Set<string>, metadata: RouterMetadataInput, features: RoutingFeatures, state: RoutingInstructionState, allowAliasRotation?: boolean): {
+        providerKey: string;
+        routeUsed: string;
+        pool: string[];
+        poolId?: string;
+    } | null;
+    extractExcludedProviderKeySet(metadata: RouterMetadataInput | undefined): Set<string>;
+    resolveSelectionPenalty(providerKey: string): number | undefined;
+    resolveInstructionProcessModeForSelection(providerKey: string, routingState: RoutingInstructionState): 'chat' | 'passthrough' | undefined;
+    resolveInstructionTarget(target: NonNullable<RoutingInstructionState['forcedTarget']>): {
+        mode: 'exact' | 'filter';
+        keys: string[];
+    } | null;
+    buildStickyRouteCandidatesFromFiltered(filteredCandidates: string[], stickyKeySet: Set<string>): string[];
+    filterCandidatesByRoutingState(routes: string[], state: RoutingInstructionState): string[];
+    resolveStickyKey(metadata: RouterMetadataInput): string | undefined;
+    resolveSessionScope(metadata: RouterMetadataInput): string | undefined;
+}

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

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

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

@@ -19,6 +19,7 @@ export type StopMessageRuntimeSummary = {
 };
 export type VirtualRouterHitRecord = {
     timestampMs: number;
+    requestId?: string;
     routeName: string;
     poolId?: string;
     providerKey: string;
@@ -34,6 +35,7 @@ export type VirtualRouterHitEventMeta = {
     entryEndpoint?: string;
 };
 export declare function createVirtualRouterHitRecord(input: {
+    requestId?: string;
     routeName: string;
     poolId?: string;
     providerKey: string;

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

@@ -18,23 +18,24 @@ function summarizeStopMessageRuntime(state) {
     const parsedMaxRepeats = typeof state.stopMessageMaxRepeats === 'number' && Number.isFinite(state.stopMessageMaxRepeats)
         ? Math.max(0, Math.floor(state.stopMessageMaxRepeats))
         : 0;
+    const hasGoalText = Boolean(text);
     const maxRepeats = parsedMaxRepeats > 0
         ? parsedMaxRepeats
-        : mode === 'on' || mode === 'auto'
+        : hasGoalText && (mode === 'on' || mode === 'auto')
             ? DEFAULT_STOP_MESSAGE_MAX_REPEATS
             : 0;
     const used = typeof state.stopMessageUsed === 'number' && Number.isFinite(state.stopMessageUsed)
         ? Math.max(0, Math.floor(state.stopMessageUsed))
         : 0;
     const remaining = maxRepeats > 0 ? Math.max(0, maxRepeats - used) : -1;
-    const active = mode !== 'off' && maxRepeats > 0 && (Boolean(text) || mode === 'on' || mode === 'auto');
+    const active = mode !== 'off' && hasGoalText && maxRepeats > 0;
     const updatedAt = typeof state.stopMessageUpdatedAt === 'number' && Number.isFinite(state.stopMessageUpdatedAt)
         ? state.stopMessageUpdatedAt
         : undefined;
     const lastUsedAt = typeof state.stopMessageLastUsedAt === 'number' && Number.isFinite(state.stopMessageLastUsedAt)
         ? state.stopMessageLastUsedAt
         : undefined;
-    const hasAny = Boolean(text) || maxRepeats > 0 || mode !== 'unset' || used > 0;
+    const hasAny = hasGoalText || maxRepeats > 0 || used > 0;
     return {
         hasAny,
         ...(safeText ? { safeText } : {}),
@@ -64,6 +65,7 @@ export function createVirtualRouterHitRecord(input) {
         timestampMs: typeof input.timestampMs === 'number' && Number.isFinite(input.timestampMs)
             ? input.timestampMs
             : Date.now(),
+        ...(input.requestId ? { requestId: input.requestId } : {}),
         routeName: input.routeName,
         ...(input.poolId ? { poolId: input.poolId } : {}),
         providerKey: input.providerKey,
@@ -248,6 +250,8 @@ export function formatVirtualRouterHit(record) {
         const { providerLabel, resolvedModel } = describeTargetProvider(record.providerKey, record.modelId);
         const routeLabel = record.poolId ? `${record.routeName}/${record.poolId}` : record.routeName;
         const targetLabel = `${routeLabel} -> ${providerLabel}${resolvedModel ? '.' + resolvedModel : ''}`;
+        const requestId = typeof record.requestId === 'string' ? record.requestId : '';
+        const requestLabel = requestId && !requestId.includes('unknown') ? ` req=${requestId}` : '';
         const stickyText = formatStickyScope(record.stickyScope);
         const stickyLabel = stickyText ? ` ${stickyColor}[sticky:${stickyText}]${reset}` : '';
         const reasonLabel = record.hitReason ? ` reason=${record.hitReason}` : '';
@@ -275,7 +279,7 @@ export function formatVirtualRouterHit(record) {
             }
             stopLabel = ` ${stopColor}[stopMessage:${parts.join(' ')}]${reset}`;
         }
-        return `${prefix} ${timeLabel} ${routeColor}${targetLabel}${stickyLabel}${reasonLabel}${requestTokenLabel}${penaltyLabel}${stopLabel}${reset}`;
+        return `${prefix} ${timeLabel}${requestLabel} ${routeColor}${targetLabel}${stickyLabel}${reasonLabel}${requestTokenLabel}${penaltyLabel}${stopLabel}${reset}`;
     }
     catch {
         const now = new Date(record.timestampMs);
@@ -283,6 +287,8 @@ export function formatVirtualRouterHit(record) {
         const routeLabel = record.poolId ? `${record.routeName}/${record.poolId}` : record.routeName;
         const stickyText = formatStickyScope(record.stickyScope);
         const stickyLabel = stickyText ? ` [sticky:${stickyText}]` : '';
+        const requestId = typeof record.requestId === 'string' ? record.requestId : '';
+        const requestLabel = requestId && !requestId.includes('unknown') ? ` req=${requestId}` : '';
         const requestTokenLabel = typeof record.requestTokens === 'number' && Number.isFinite(record.requestTokens)
             ? ` reqTokens=${Math.max(0, Math.round(record.requestTokens))}`
             : '';
@@ -297,6 +303,6 @@ export function formatVirtualRouterHit(record) {
             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} -> ${record.providerKey}${record.modelId ? '.' + record.modelId : ''}${stickyLabel}${record.hitReason ? ` reason=${record.hitReason}` : ''}${requestTokenLabel}${penaltyLabel}${stopLabel}`;
+        return `[virtual-router-hit] ${timestamp}${requestLabel} ${routeLabel} -> ${record.providerKey}${record.modelId ? '.' + record.modelId : ''}${stickyLabel}${record.hitReason ? ` reason=${record.hitReason}` : ''}${requestTokenLabel}${penaltyLabel}${stopLabel}`;
     }
 }