@jsonstudio/llms 0.6.2979 → 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

@@ -65,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,
@@ -249,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}` : '';
@@ -276,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);
@@ -284,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))}`
             : '';
@@ -298,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}`;
     }
 }

package/dist/router/virtual-router/engine-selection/key-parsing.js

@@ -13,9 +13,6 @@ export function extractKeyAlias(providerKey) {
     return normalizeAliasDescriptor(alias);
 }
 export function normalizeAliasDescriptor(alias) {
-    if (/^\d+-/.test(alias)) {
-        return alias.replace(/^\d+-/, '');
-    }
     return alias;
 }
 export function extractKeyIndex(providerKey) {

package/dist/router/virtual-router/engine-selection/native-chat-request-filter-semantics.d.ts

@@ -0,0 +1 @@
+export declare function buildGovernedFilterPayloadWithNativeFallback(request: unknown): Record<string, unknown>;

package/dist/router/virtual-router/engine-selection/native-chat-request-filter-semantics.js

@@ -0,0 +1,54 @@
+import { failNativeRequired, isNativeDisabledByEnv } from './native-router-hotpath-policy.js';
+import { loadNativeRouterHotpathBindingForInternalUse } from './native-router-hotpath.js';
+function readNativeFunction(name) {
+    const binding = loadNativeRouterHotpathBindingForInternalUse();
+    const fn = binding?.[name];
+    return typeof fn === 'function' ? fn : null;
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseOutputRecord(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export function buildGovernedFilterPayloadWithNativeFallback(request) {
+    const capability = 'buildGovernedFilterPayloadJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const requestJson = safeStringify(request);
+    if (!requestJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(requestJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseOutputRecord(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}

package/dist/router/virtual-router/engine-selection/native-hub-bridge-policy-semantics.d.ts

@@ -47,6 +47,15 @@ export interface NativeProtocolSpec {
     providerOutbound: NativeProviderOutboundPolicySpec;
     toolSurface: NativeToolSurfaceSpec;
 }
+export interface NativeHubProtocolAllowlists {
+    openaiChatAllowedFields: string[];
+    openaiChatParametersWrapperAllowKeys: string[];
+    openaiResponsesAllowedFields: string[];
+    openaiResponsesParametersWrapperAllowKeys: string[];
+    anthropicAllowedFields: string[];
+    anthropicParametersWrapperAllowKeys: string[];
+    geminiAllowedFields: string[];
+}
 export declare function resolveHubProtocolSpecWithNative(input: {
     protocol?: string;
     allowlists: {
@@ -59,4 +68,5 @@ export declare function resolveHubProtocolSpecWithNative(input: {
         geminiAllowedFields: readonly string[];
     };
 }): NativeProtocolSpec;
+export declare function resolveHubProtocolAllowlistsWithNative(): NativeHubProtocolAllowlists;
 export {};

package/dist/router/virtual-router/engine-selection/native-hub-bridge-policy-semantics.js

@@ -298,6 +298,50 @@ function parseProtocolSpec(raw) {
         return null;
     }
 }
+function parseStringArrayValue(value) {
+    if (!Array.isArray(value)) {
+        return null;
+    }
+    const out = value.filter((entry) => typeof entry === 'string');
+    return out;
+}
+function parseHubProtocolAllowlists(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return null;
+        }
+        const row = parsed;
+        const openaiChatAllowedFields = parseStringArrayValue(row.openaiChatAllowedFields);
+        const openaiChatParametersWrapperAllowKeys = parseStringArrayValue(row.openaiChatParametersWrapperAllowKeys);
+        const openaiResponsesAllowedFields = parseStringArrayValue(row.openaiResponsesAllowedFields);
+        const openaiResponsesParametersWrapperAllowKeys = parseStringArrayValue(row.openaiResponsesParametersWrapperAllowKeys);
+        const anthropicAllowedFields = parseStringArrayValue(row.anthropicAllowedFields);
+        const anthropicParametersWrapperAllowKeys = parseStringArrayValue(row.anthropicParametersWrapperAllowKeys);
+        const geminiAllowedFields = parseStringArrayValue(row.geminiAllowedFields);
+        if (!openaiChatAllowedFields ||
+            !openaiChatParametersWrapperAllowKeys ||
+            !openaiResponsesAllowedFields ||
+            !openaiResponsesParametersWrapperAllowKeys ||
+            !anthropicAllowedFields ||
+            !anthropicParametersWrapperAllowKeys ||
+            !geminiAllowedFields) {
+            return null;
+        }
+        return {
+            openaiChatAllowedFields,
+            openaiChatParametersWrapperAllowKeys,
+            openaiResponsesAllowedFields,
+            openaiResponsesParametersWrapperAllowKeys,
+            anthropicAllowedFields,
+            anthropicParametersWrapperAllowKeys,
+            geminiAllowedFields
+        };
+    }
+    catch {
+        return null;
+    }
+}
 export function resolveHubProtocolSpecWithNative(input) {
     const capability = 'resolveHubProtocolSpecJson';
     const fail = (reason) => failNativeRequired(capability, reason);
@@ -336,3 +380,26 @@ export function resolveHubProtocolSpecWithNative(input) {
         return fail(reason);
     }
 }
+export function resolveHubProtocolAllowlistsWithNative() {
+    const capability = 'resolveHubProtocolAllowlistsJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    try {
+        const raw = fn();
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseHubProtocolAllowlists(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}