@jsonstudio/llms 0.6.2979 → 0.6.3238

package/dist/router/virtual-router/engine-selection/native-virtual-router-routing-instructions-semantics.js

@@ -0,0 +1,86 @@
+import { failNativeRequired } 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 parseArrayPayload(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return null;
+        return parsed.filter((entry) => typeof entry === 'string');
+    }
+    catch {
+        return null;
+    }
+}
+function parseRecordPayload(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export function parseRoutingInstructionKindsWithNative(request) {
+    const capability = 'parseRoutingInstructionKindsJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const requestJson = safeStringify(request);
+    if (!requestJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const result = fn(requestJson);
+        if (typeof result !== 'string' || !result) {
+            return fail('empty result');
+        }
+        const parsed = parseArrayPayload(result);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function cleanRoutingInstructionMarkersWithNative(request) {
+    const capability = 'cleanRoutingInstructionMarkersJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const requestJson = safeStringify(request);
+    if (!requestJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const result = fn(requestJson);
+        if (typeof result !== 'string' || !result) {
+            return fail('empty result');
+        }
+        const parsed = parseRecordPayload(result);
+        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/tier-selection-quota-integration.js

@@ -3,6 +3,72 @@ import { computeHealthWeight } from '../health-weighted.js';
 import { buildQuotaBuckets } from './native-router-hotpath.js';
 import { computeContextWeightMultipliers } from './context-weight-multipliers.js';
 import { pickPriorityGroup } from './tier-priority.js';
+import { extractProviderId, getProviderModelId } from './key-parsing.js';
+function buildPrimaryTargetGroups(candidates, deps) {
+    const groups = new Map();
+    for (const key of candidates) {
+        const providerId = extractProviderId(key) ?? '';
+        if (!providerId) {
+            continue;
+        }
+        let modelId;
+        try {
+            modelId = getProviderModelId(key, deps.providerRegistry) ?? undefined;
+        }
+        catch {
+            modelId = undefined;
+        }
+        const groupId = modelId ? `${providerId}.${modelId}` : providerId;
+        const entry = groups.get(groupId) ?? [];
+        entry.push(key);
+        groups.set(groupId, entry);
+    }
+    return groups;
+}
+function resolveGroupWeight(groupId, weights) {
+    if (!weights) {
+        return 1;
+    }
+    const direct = weights[groupId];
+    if (typeof direct === 'number' && Number.isFinite(direct) && direct > 0) {
+        return direct;
+    }
+    const providerId = groupId.split('.')[0] ?? groupId;
+    const providerOnly = weights[providerId];
+    if (typeof providerOnly === 'number' && Number.isFinite(providerOnly) && providerOnly > 0) {
+        return providerOnly;
+    }
+    return 1;
+}
+function buildGroupWeights(groups, weights) {
+    if (!groups.size) {
+        return undefined;
+    }
+    const out = {};
+    for (const [groupId] of groups.entries()) {
+        out[groupId] = resolveGroupWeight(groupId, weights);
+    }
+    return out;
+}
+function hasNonUniformWeights(candidates, weights) {
+    if (!weights || candidates.length < 2) {
+        return false;
+    }
+    let ref;
+    for (const key of candidates) {
+        const raw = weights[key];
+        if (typeof raw !== 'number' || !Number.isFinite(raw)) {
+            continue;
+        }
+        if (ref === undefined) {
+            ref = raw;
+        }
+        else if (Math.abs(raw - ref) > 1e-6) {
+            return true;
+        }
+    }
+    return false;
+}
 export function selectProviderKeyWithQuotaBuckets(opts) {
     const { routeName, tier, stickyKey, candidates, isSafePool, deps, options, contextResult, warnRatio, isRecoveryAttempt, now, nowForWeights, healthWeightedCfg, contextWeightedCfg, quotaView, isAvailable, selectFirstAvailable, applyAliasStickyQueuePinning, preferAntigravityAliasesOnRetry } = opts;
     const bucketInputs = candidates.map((key, order) => {
@@ -78,6 +144,23 @@ export function selectProviderKeyWithQuotaBuckets(opts) {
                 for (const key of group.groupCandidates) {
                     groupWeights[key] = bucketWeights[key] ?? 1;
                 }
+                const allowGrouped = !hasNonUniformWeights(group.groupCandidates, bucketWeights);
+                if (allowGrouped && deps.loadBalancer.getPolicy().strategy !== 'sticky') {
+                    const groups = buildPrimaryTargetGroups(group.groupCandidates, deps);
+                    if (groups.size > 0) {
+                        const groupWeightMap = buildGroupWeights(groups, deps.loadBalancer.getPolicy().weights);
+                        const selected = deps.loadBalancer.selectGrouped({
+                            routeName: `${routeName}:${tier.id}:priority:${priority}:group:${group.groupId}`,
+                            groups,
+                            stickyKey: options.allowAliasRotation ? undefined : stickyKey,
+                            weights: groupWeightMap,
+                            availabilityCheck: isAvailable
+                        }, 'round-robin');
+                        if (selected) {
+                            return selected;
+                        }
+                    }
+                }
                 const selected = deps.loadBalancer.select({
                     routeName: `${routeName}:${tier.id}:priority:${priority}:group:${group.groupId}`,
                     candidates: group.groupCandidates,
@@ -101,6 +184,23 @@ export function selectProviderKeyWithQuotaBuckets(opts) {
                 return recovered;
             continue;
         }
+        const allowGrouped = !hasNonUniformWeights(bucketCandidates, bucketWeights);
+        if (allowGrouped && deps.loadBalancer.getPolicy().strategy !== 'sticky') {
+            const groups = buildPrimaryTargetGroups(bucketCandidates, deps);
+            if (groups.size > 0) {
+                const groupWeightMap = buildGroupWeights(groups, deps.loadBalancer.getPolicy().weights);
+                const selected = deps.loadBalancer.selectGrouped({
+                    routeName: `${routeName}:${tier.id}:${priority}`,
+                    groups,
+                    stickyKey: options.allowAliasRotation ? undefined : stickyKey,
+                    weights: groupWeightMap,
+                    availabilityCheck: isAvailable
+                }, tier.mode === 'round-robin' ? 'round-robin' : undefined);
+                if (selected) {
+                    return selected;
+                }
+            }
+        }
         const selected = deps.loadBalancer.select({
             routeName: `${routeName}:${tier.id}`,
             candidates: bucketCandidates,

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

@@ -4,6 +4,71 @@ import { computeContextWeightMultipliers } from './context-weight-multipliers.js
 import { extractKeyAlias, extractProviderId, getProviderModelId } from './key-parsing.js';
 import { pickPriorityGroup } from './tier-priority.js';
 import { selectProviderKeyWithQuotaBuckets } from './tier-selection-quota-integration.js';
+function buildPrimaryTargetGroups(candidates, deps) {
+    const groups = new Map();
+    for (const key of candidates) {
+        const providerId = extractProviderId(key) ?? '';
+        if (!providerId) {
+            continue;
+        }
+        let modelId;
+        try {
+            modelId = getProviderModelId(key, deps.providerRegistry) ?? undefined;
+        }
+        catch {
+            modelId = undefined;
+        }
+        const groupId = modelId ? `${providerId}.${modelId}` : providerId;
+        const entry = groups.get(groupId) ?? [];
+        entry.push(key);
+        groups.set(groupId, entry);
+    }
+    return groups;
+}
+function resolveGroupWeight(groupId, weights) {
+    if (!weights) {
+        return 1;
+    }
+    const direct = weights[groupId];
+    if (typeof direct === 'number' && Number.isFinite(direct) && direct > 0) {
+        return direct;
+    }
+    const providerId = groupId.split('.')[0] ?? groupId;
+    const providerOnly = weights[providerId];
+    if (typeof providerOnly === 'number' && Number.isFinite(providerOnly) && providerOnly > 0) {
+        return providerOnly;
+    }
+    return 1;
+}
+function buildGroupWeights(groups, weights) {
+    if (!groups.size) {
+        return undefined;
+    }
+    const out = {};
+    for (const [groupId] of groups.entries()) {
+        out[groupId] = resolveGroupWeight(groupId, weights);
+    }
+    return out;
+}
+function hasNonUniformWeights(candidates, weights) {
+    if (!weights || candidates.length < 2) {
+        return false;
+    }
+    let ref;
+    for (const key of candidates) {
+        const raw = weights[key];
+        if (typeof raw !== 'number' || !Number.isFinite(raw)) {
+            continue;
+        }
+        if (ref === undefined) {
+            ref = raw;
+        }
+        else if (Math.abs(raw - ref) > 1e-6) {
+            return true;
+        }
+    }
+    return false;
+}
 function applyAliasStickyQueuePinning(opts) {
     const { candidates, orderedTargets, deps, excludedKeys } = opts;
     if (!Array.isArray(candidates) || candidates.length < 2) {
@@ -217,6 +282,23 @@ export function selectProviderKeyFromCandidatePool(opts) {
                 }
                 return out;
             })();
+            const allowGrouped = !hasNonUniformWeights(group.groupCandidates, weights);
+            if (allowGrouped && deps.loadBalancer.getPolicy().strategy !== 'sticky') {
+                const groups = buildPrimaryTargetGroups(group.groupCandidates, deps);
+                if (groups.size > 0) {
+                    const groupWeights = buildGroupWeights(groups, deps.loadBalancer.getPolicy().weights);
+                    const selected = deps.loadBalancer.selectGrouped({
+                        routeName: `${routeName}:${tier.id}:priority:group:${group.groupId}`,
+                        groups,
+                        stickyKey: options.allowAliasRotation ? undefined : stickyKey,
+                        weights: groupWeights,
+                        availabilityCheck: isAvailable
+                    }, 'round-robin');
+                    if (selected) {
+                        return selected;
+                    }
+                }
+            }
             return deps.loadBalancer.select({
                 routeName: `${routeName}:${tier.id}:priority:group:${group.groupId}`,
                 candidates: group.groupCandidates,
@@ -242,6 +324,23 @@ export function selectProviderKeyFromCandidatePool(opts) {
             }
             return out;
         })();
+        const allowGrouped = !hasNonUniformWeights(pinnedCandidates, weights);
+        if (allowGrouped && deps.loadBalancer.getPolicy().strategy !== 'sticky') {
+            const groups = buildPrimaryTargetGroups(pinnedCandidates, deps);
+            if (groups.size > 0) {
+                const groupWeights = buildGroupWeights(groups, deps.loadBalancer.getPolicy().weights);
+                const selected = deps.loadBalancer.selectGrouped({
+                    routeName: `${routeName}:${tier.id}`,
+                    groups,
+                    stickyKey: options.allowAliasRotation ? undefined : stickyKey,
+                    weights: groupWeights,
+                    availabilityCheck: isAvailable
+                }, tier.mode === 'round-robin' ? 'round-robin' : undefined);
+                if (selected) {
+                    return selected;
+                }
+            }
+        }
         return deps.loadBalancer.select({
             routeName: `${routeName}:${tier.id}`,
             candidates: pinnedCandidates,

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

@@ -1,51 +1,34 @@
-import { type RoutingDecision, type RoutingDiagnostics, type StopMessageStateSnapshot, type PreCommandStateSnapshot, type RouterMetadataInput, type VirtualRouterConfig, type TargetMetadata, type ProviderFailureEvent, type ProviderErrorEvent, type ProviderSuccessEvent, type VirtualRouterHealthStore } from './types.js';
 import type { ProcessedRequest, StandardizedRequest } from '../../conversion/hub/types/standardized.js';
-import { type RoutingInstructionState } from './routing-instructions.js';
-import type { ProviderQuotaView } from './types.js';
-interface RoutingInstructionStateStore {
-    loadSync(key: string): RoutingInstructionState | null;
-    saveAsync(key: string, state: RoutingInstructionState | null): void;
-    saveSync?: (key: string, state: RoutingInstructionState | null) => void;
-}
+import type { ProviderErrorEvent, ProviderFailureEvent, ProviderQuotaView, ProviderSuccessEvent, RouterMetadataInput, RoutingDecision, RoutingDiagnostics, RoutingStatusSnapshot, StopMessageStateSnapshot, PreCommandStateSnapshot, TargetMetadata, VirtualRouterConfig, VirtualRouterHealthStore } from './types.js';
 export declare class VirtualRouterEngine {
-    private routing;
-    private readonly providerRegistry;
-    private readonly healthManager;
-    private get providerCooldowns();
-    private loadBalancer;
-    private classifier;
-    private readonly contextAdvisor;
-    private contextRouting;
-    private readonly routeAnalytics;
-    private stickySessionManager;
-    private cooldownManager;
-    private antigravityLeasePersistence;
-    private readonly debug;
-    private healthConfig;
-    private readonly statsCenter;
-    private webSearchForce;
-    private healthStore?;
-    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>;
+    private readonly nativeProxy;
+    private readonly registry;
+    private readonly routingInstructionStateStore;
     constructor(deps?: {
         healthStore?: VirtualRouterHealthStore;
-        routingStateStore?: RoutingInstructionStateStore;
+        routingStateStore?: {
+            loadSync: (key: string) => unknown;
+            saveAsync: (key: string, state: unknown) => void;
+            saveSync?: (key: string, state: unknown) => void;
+        };
         quotaView?: ProviderQuotaView;
     });
+    get antigravitySessionAliasStore(): Map<string, string>;
+    get routingInstructionState(): Map<string, unknown>;
+    get providerRegistry(): unknown;
+    initialize(config: VirtualRouterConfig): void;
     updateDeps(deps: {
         healthStore?: VirtualRouterHealthStore | null;
-        routingStateStore?: RoutingInstructionStateStore | null;
+        routingStateStore?: {
+            loadSync: (key: string) => unknown;
+            saveAsync: (key: string, state: unknown) => void;
+            saveSync?: (key: string, state: unknown) => void;
+        } | null;
         quotaView?: ProviderQuotaView | null;
     }): void;
-    private parseDirectProviderModel;
-    private shouldFallbackDirectModelForMedia;
-    initialize(config: VirtualRouterConfig): void;
+    updateVirtualRouterConfig(config: VirtualRouterConfig): void;
+    markProviderCooldown(providerKey: string, cooldownMs: number | undefined): void;
+    clearProviderCooldown(providerKey: string): void;
     route(request: StandardizedRequest | ProcessedRequest, metadata: RouterMetadataInput): {
         target: TargetMetadata;
         decision: RoutingDecision;
@@ -56,71 +39,5 @@ export declare class VirtualRouterEngine {
     handleProviderFailure(event: ProviderFailureEvent): void;
     handleProviderError(event: ProviderErrorEvent): void;
     handleProviderSuccess(event: ProviderSuccessEvent): void;
-    getStatus(): {
-        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[];
-    };
-    /**
-     * 将分类器产生的逻辑路由名直接归一化为配置中的路由键。
-     * 不再维护 "websearch" 之类的别名，调用方应显式使用 "web_search" 或 "search" 等实际路由名。
-     */
-    private normalizeRouteAlias;
-    private validateConfig;
-    private selectProvider;
-    private resolveSelectionPenalty;
-    private providerHealthConfig;
-    private resolveStickyKey;
-    private resolveSessionScope;
-    private resolveInstructionProcessModeForSelection;
-    private resolveInstructionTarget;
-    private filterCandidatesByRoutingState;
-    private selectFromCandidates;
-    /**
-     * 在已有候选路由集合上，筛选出真正挂载了 sticky 池内 providerKey 的路由，
-     * 并按 ROUTE_PRIORITY 进行排序；同时显式排除 tools 路由，保证一旦进入
-     * sticky 模式，就不会再命中独立的 tools 池（例如 glm/qwen 工具模型）。
-     * 若候选集合中完全没有挂载 sticky key 的路由，则尝试在 default 路由上兜底。
-     */
-    private buildStickyRouteCandidatesFromFiltered;
-    /**
-     * 在 sticky 模式下，仅在 sticky 池内选择 Provider：
-     * - stickyKeySet 表示已经解析并通过健康检查的 providerKey 集合；
-     * - 不再依赖 routing[*].targets 中是否挂载这些 key，避免「未初始化路由池」导致 sticky 池为空；
-     * - 仍然尊重 allowed/disabledProviders、disabledKeys、disabledModels 以及上下文长度。
-     */
-    private selectFromStickyPool;
-    private extractExcludedProviderKeySet;
-    private buildRouteCandidates;
-    private reorderForInlineVision;
-    private reorderForPreferredModel;
-    private routeSupportsModel;
-    private routeSupportsInlineVision;
-    private sortByPriority;
-    private routeWeight;
-    private routeHasForceFlag;
-    private routeHasTargets;
-    private hasPrimaryPool;
-    private sortRoutePools;
-    private flattenPoolTargets;
-    private markProviderCooldown;
-    private clearProviderCooldown;
-    private isProviderCoolingDown;
-    private getProviderCooldownRemainingMs;
-    private restoreHealthFromStore;
-    private buildHealthSnapshot;
-    private persistHealthSnapshot;
+    getStatus(): RoutingStatusSnapshot;
 }
-export {};