@jsonstudio/rcc 0.90.352 → 0.90.367

package/vendor/llmswitch-core/dist/router/virtual-router/engine-legacy/selection-state.js

@@ -0,0 +1,187 @@
+import { DEFAULT_ROUTE } from '../types.js';
+import { extractKeyAlias, extractKeyIndex, extractProviderId, getProviderModelId } from '../engine/provider-key/parse.js';
+import { routeHasTargets, sortByPriority, flattenPoolTargets } from './route-utils.js';
+export function resolveSelectionPenalty(engine, providerKey) {
+    if (!engine.quotaView) {
+        return undefined;
+    }
+    try {
+        const entry = engine.quotaView(providerKey);
+        const raw = entry?.selectionPenalty;
+        if (typeof raw !== 'number' || !Number.isFinite(raw) || raw <= 0) {
+            return undefined;
+        }
+        return Math.floor(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function resolveInstructionProcessModeForSelection(engine, providerKey, routingState) {
+    const candidates = [
+        routingState.forcedTarget,
+        routingState.stickyTarget,
+        routingState.preferTarget
+    ];
+    for (const candidate of candidates) {
+        const processMode = candidate?.processMode;
+        if (!processMode) {
+            continue;
+        }
+        const resolved = resolveInstructionTarget(engine, candidate);
+        if (!resolved) {
+            continue;
+        }
+        if (resolved.keys.includes(providerKey)) {
+            return processMode;
+        }
+    }
+    return undefined;
+}
+export function resolveInstructionTarget(engine, target) {
+    if (!target || !target.provider) {
+        return null;
+    }
+    const providerId = target.provider;
+    const providerKeys = engine.providerRegistry.listProviderKeys(providerId);
+    if (providerKeys.length === 0) {
+        return null;
+    }
+    const alias = typeof target.keyAlias === 'string' ? target.keyAlias.trim() : '';
+    const aliasExplicit = alias.length > 0 && target.pathLength === 3;
+    if (aliasExplicit) {
+        const runtimeKey = engine.providerRegistry.resolveRuntimeKeyByAlias(providerId, alias);
+        if (runtimeKey) {
+            return { mode: 'exact', keys: [runtimeKey] };
+        }
+    }
+    if (typeof target.keyIndex === 'number' && target.keyIndex > 0) {
+        const runtimeKey = engine.providerRegistry.resolveRuntimeKeyByIndex(providerId, target.keyIndex);
+        if (runtimeKey) {
+            return { mode: 'exact', keys: [runtimeKey] };
+        }
+    }
+    if (target.model && target.model.trim()) {
+        const normalizedModel = target.model.trim();
+        const matchingKeys = providerKeys.filter((key) => {
+            const modelId = getProviderModelId(key, engine.providerRegistry);
+            return modelId === normalizedModel;
+        });
+        if (matchingKeys.length > 0) {
+            return { mode: 'filter', keys: matchingKeys };
+        }
+    }
+    if (alias && !aliasExplicit) {
+        const legacyKey = engine.providerRegistry.resolveRuntimeKeyByAlias(providerId, alias);
+        if (legacyKey) {
+            return { mode: 'exact', keys: [legacyKey] };
+        }
+    }
+    return { mode: 'filter', keys: providerKeys };
+}
+export function filterCandidatesByRoutingState(engine, routes, state) {
+    // console.log('[filter] routes:', routes, 'state:', {
+    //   allowed: Array.from(state.allowedProviders),
+    //   disabled: Array.from(state.disabledProviders)
+    // });
+    if (state.allowedProviders.size === 0 &&
+        state.disabledProviders.size === 0 &&
+        state.disabledKeys.size === 0 &&
+        state.disabledModels.size === 0) {
+        return routes;
+    }
+    return routes.filter((routeName) => {
+        const pools = engine.routing[routeName];
+        if (!pools)
+            return false;
+        for (const pool of pools) {
+            if (!Array.isArray(pool.targets) || pool.targets.length === 0) {
+                continue;
+            }
+            for (const providerKey of pool.targets) {
+                const providerId = extractProviderId(providerKey);
+                // console.log('[filter] checking', providerKey, 'id=', providerId);
+                if (!providerId)
+                    continue;
+                if (state.allowedProviders.size > 0 && !state.allowedProviders.has(providerId)) {
+                    // console.log('[filter] dropped by allowed list');
+                    continue;
+                }
+                if (state.disabledProviders.has(providerId)) {
+                    continue;
+                }
+                const disabledKeys = state.disabledKeys.get(providerId);
+                if (disabledKeys && disabledKeys.size > 0) {
+                    const keyAlias = extractKeyAlias(providerKey);
+                    const keyIndex = extractKeyIndex(providerKey);
+                    if (keyAlias && disabledKeys.has(keyAlias)) {
+                        continue;
+                    }
+                    if (keyIndex !== undefined && disabledKeys.has(keyIndex + 1)) {
+                        continue;
+                    }
+                }
+                const disabledModels = state.disabledModels.get(providerId);
+                if (disabledModels && disabledModels.size > 0) {
+                    const modelId = getProviderModelId(providerKey, engine.providerRegistry);
+                    if (modelId && disabledModels.has(modelId)) {
+                        continue;
+                    }
+                }
+                return true;
+            }
+        }
+        return false;
+    });
+}
+/**
+ * 在已有候选路由集合上，筛选出真正挂载了 sticky 池内 providerKey 的路由，
+ * 并按 ROUTE_PRIORITY 进行排序；同时显式排除 tools 路由，保证一旦进入
+ * sticky 模式，就不会再命中独立的 tools 池（例如 glm/qwen 工具模型）。
+ * 若候选集合中完全没有挂载 sticky key 的路由，则尝试在 default 路由上兜底。
+ */
+export function buildStickyRouteCandidatesFromFiltered(engine, filteredCandidates, stickyKeySet) {
+    const routesWithSticky = [];
+    const candidateSet = new Set(filteredCandidates.filter((name) => name && name !== 'tools'));
+    for (const routeName of candidateSet) {
+        const pools = engine.routing[routeName];
+        if (!routeHasTargets(engine, pools)) {
+            continue;
+        }
+        const targets = flattenPoolTargets(engine, pools);
+        if (!targets.some((key) => stickyKeySet.has(key))) {
+            continue;
+        }
+        routesWithSticky.push(routeName);
+    }
+    // 若当前候选路由中没有任何挂载 sticky key 的路由，尝试直接在 default 路由上兜底；
+    // 若 default 也不包含 sticky key，则视为 sticky 配置失效，由调用方回落到非 sticky 逻辑。
+    if (routesWithSticky.length === 0) {
+        const defaultPools = engine.routing[DEFAULT_ROUTE];
+        if (routeHasTargets(engine, defaultPools)) {
+            const targets = flattenPoolTargets(engine, defaultPools);
+            if (targets.some((key) => stickyKeySet.has(key))) {
+                return [DEFAULT_ROUTE];
+            }
+        }
+        return [];
+    }
+    const ordered = sortByPriority(routesWithSticky);
+    const result = [];
+    let hasDefault = false;
+    for (const routeName of ordered) {
+        if (routeName === DEFAULT_ROUTE) {
+            hasDefault = true;
+            continue;
+        }
+        if (!result.includes(routeName)) {
+            result.push(routeName);
+        }
+    }
+    // default 路由若包含 sticky key，则始终放在候选列表最后，用于 sticky 模式兜底。
+    if (hasDefault && !result.includes(DEFAULT_ROUTE)) {
+        result.push(DEFAULT_ROUTE);
+    }
+    return result;
+}
+// Intentionally no extra exports here; keep this module focused on state filtering.

package/vendor/llmswitch-core/dist/router/virtual-router/engine-legacy/state-accessors.d.ts

@@ -0,0 +1,21 @@
+import type { PreCommandStateSnapshot, RouterMetadataInput, StopMessageStateSnapshot } from '../types.js';
+import type { VirtualRouterEngine } from '../engine-legacy.js';
+export declare function getStopMessageState(engine: VirtualRouterEngine, metadata: RouterMetadataInput): StopMessageStateSnapshot | null;
+export declare function getPreCommandState(engine: VirtualRouterEngine, metadata: RouterMetadataInput): PreCommandStateSnapshot | null;
+export declare function getStatus(engine: VirtualRouterEngine): {
+    routes: Record<string, {
+        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[];
+};

package/vendor/llmswitch-core/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/vendor/llmswitch-core/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 RoutingStatusSnapshot, 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';
+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;
+    private readonly nativeEngine;
+    /**
+     * 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(): RoutingStatusSnapshot;
+    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;
+}