@jsonstudio/llms 0.6.954 → 0.6.1164

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

@@ -1,3 +1,4 @@
+import { computeHealthWeight, resolveHealthWeightedConfig } from './health-weighted.js';
 import { DEFAULT_ROUTE, ROUTE_PRIORITY, VirtualRouterError, VirtualRouterErrorCode } from './types.js';
 export function selectProviderImpl(requestedRoute, metadata, classification, features, activeState, deps, options = {}) {
     const state = options.routingState ?? activeState;
@@ -294,12 +295,13 @@ function trySelectFromTier(routeName, tier, stickyKey, estimatedTokens, features
     if (excludedKeys.size > 0) {
         targets = targets.filter((key) => !excludedKeys.has(key));
     }
+    const isRecoveryAttempt = excludedKeys.size > 0;
+    const singleCandidateFallback = targets.length === 1 ? targets[0] : undefined;
     if (targets.length > 0) {
-        const cooled = targets.filter((key) => !deps.isProviderCoolingDown(key));
-        // 单 provider 兜底：当一个 tier 只有一个候选 key 时，不因 cooldown 造成路由池为空。
-        if (cooled.length > 0 || targets.length !== 1) {
-            targets = cooled;
-        }
+        // Always respect cooldown signals. If a route/tier is depleted due to cooldown,
+        // routing is expected to fall back to other tiers/routes (e.g. longcontext → default),
+        // rather than repeatedly selecting the cooled-down provider.
+        targets = targets.filter((key) => !deps.isProviderCoolingDown(key));
     }
     if (allowedProviders && allowedProviders.size > 0) {
         targets = targets.filter((key) => {
@@ -399,6 +401,7 @@ function trySelectFromTier(routeName, tier, stickyKey, estimatedTokens, features
     const prioritizedPools = buildContextCandidatePools(contextResult);
     const quotaView = deps.quotaView;
     const now = quotaView ? Date.now() : 0;
+    const healthWeightedCfg = resolveHealthWeightedConfig(deps.loadBalancer.getPolicy().healthWeighted);
     const selectFirstAvailable = (candidates) => {
         for (const key of candidates) {
             if (deps.healthManager.isAvailable(key)) {
@@ -410,11 +413,15 @@ function trySelectFromTier(routeName, tier, stickyKey, estimatedTokens, features
     const selectWithQuota = (candidates) => {
         if (!quotaView) {
             if (tier.mode === 'priority') {
-                const selected = selectFirstAvailable(candidates);
-                if (!selected && candidates.length === 1) {
-                    return candidates[0];
+                if (isRecoveryAttempt) {
+                    return selectFirstAvailable(candidates);
                 }
-                return selected;
+                return deps.loadBalancer.select({
+                    routeName: `${routeName}:${tier.id}:priority`,
+                    candidates,
+                    stickyKey: options.allowAliasRotation ? undefined : stickyKey,
+                    availabilityCheck: (key) => deps.healthManager.isAvailable(key)
+                }, 'round-robin');
             }
             const selected = deps.loadBalancer.select({
                 routeName: `${routeName}:${tier.id}`,
@@ -422,17 +429,15 @@ function trySelectFromTier(routeName, tier, stickyKey, estimatedTokens, features
                 stickyKey: options.allowAliasRotation ? undefined : stickyKey,
                 availabilityCheck: (key) => deps.healthManager.isAvailable(key)
             }, tier.mode === 'round-robin' ? 'round-robin' : undefined);
-            if (!selected && candidates.length === 1) {
-                return candidates[0];
-            }
             return selected;
         }
         const buckets = new Map();
+        let order = 0;
         for (const key of candidates) {
             const entry = quotaView(key);
             if (!entry) {
                 const list = buckets.get(100) ?? [];
-                list.push(key);
+                list.push({ key, penalty: 0, order: order++ });
                 buckets.set(100, list);
                 continue;
             }
@@ -448,50 +453,140 @@ function trySelectFromTier(routeName, tier, stickyKey, estimatedTokens, features
             const tierPriority = typeof entry.priorityTier === 'number' && Number.isFinite(entry.priorityTier)
                 ? entry.priorityTier
                 : 100;
+            const penaltyRaw = entry.selectionPenalty;
+            const penalty = typeof penaltyRaw === 'number' && Number.isFinite(penaltyRaw) && penaltyRaw > 0 ? Math.floor(penaltyRaw) : 0;
             const list = buckets.get(tierPriority) ?? [];
-            list.push(key);
+            list.push({ key, penalty, order: order++ });
             buckets.set(tierPriority, list);
         }
         const sortedPriorities = Array.from(buckets.keys()).sort((a, b) => a - b);
         for (const priority of sortedPriorities) {
-            const bucketCandidates = buckets.get(priority) ?? [];
-            if (!bucketCandidates.length) {
+            const bucket = buckets.get(priority) ?? [];
+            if (!bucket.length) {
                 continue;
             }
-            if (tier.mode === 'priority') {
-                const selected = selectFirstAvailable(bucketCandidates);
-                if (selected) {
-                    return selected;
+            bucket.sort((a, b) => (a.penalty - b.penalty) || (a.order - b.order));
+            const bucketCandidates = bucket.map((item) => item.key);
+            // antigravity special: avoid rotating across keys while the current key is healthy.
+            // Rationale: some upstream gateways reject rapid cross-key switching even when quota exists,
+            // causing repeated 429s. We therefore pin a single key per (providerId, modelId) until it is
+            // excluded by quota/cooldown, then fail over to the next available key.
+            //
+            // This is only applied when the request has no session-level sticky key, to avoid breaking
+            // explicit session stickiness.
+            const shouldPinAntigravityModel = (() => {
+                // Only respect explicit session/conversation stickiness. requestId-scoped sticky keys
+                // (used for request-chain pinning) should not prevent global antigravity key pinning.
+                if (typeof stickyKey === 'string' && (stickyKey.startsWith('session:') || stickyKey.startsWith('conversation:'))) {
+                    return false;
+                }
+                if (bucketCandidates.length < 2) {
+                    return false;
+                }
+                let modelId = null;
+                for (const key of bucketCandidates) {
+                    const providerId = extractProviderId(key);
+                    if (providerId !== 'antigravity') {
+                        return false;
+                    }
+                    const candidateModel = getProviderModelId(key, deps.providerRegistry);
+                    if (!candidateModel) {
+                        return false;
+                    }
+                    if (modelId === null) {
+                        modelId = candidateModel;
+                    }
+                    else if (modelId !== candidateModel) {
+                        return false;
+                    }
+                }
+                return Boolean(modelId);
+            })();
+            if (shouldPinAntigravityModel && !isRecoveryAttempt) {
+                const pinned = selectFirstAvailable(bucketCandidates);
+                if (pinned) {
+                    return pinned;
                 }
             }
-            else {
+            const bucketWeights = {};
+            const bucketMultipliers = {};
+            for (const item of bucket) {
+                if (healthWeightedCfg.enabled) {
+                    const entry = quotaView(item.key);
+                    const { weight, multiplier } = computeHealthWeight(entry, now, healthWeightedCfg);
+                    bucketWeights[item.key] = weight;
+                    bucketMultipliers[item.key] = multiplier;
+                }
+                else {
+                    // Legacy: penalty => lower weight, but never zero (unhealthy should still get a chance).
+                    bucketWeights[item.key] = Math.max(1, Math.floor(100 / (1 + Math.max(0, item.penalty))));
+                    bucketMultipliers[item.key] = 1;
+                }
+            }
+            if (tier.mode === 'priority') {
+                if (isRecoveryAttempt && healthWeightedCfg.enabled && healthWeightedCfg.recoverToBestOnRetry) {
+                    let best = null;
+                    let bestM = Number.NEGATIVE_INFINITY;
+                    for (const key of bucketCandidates) {
+                        if (!deps.healthManager.isAvailable(key))
+                            continue;
+                        const m = bucketMultipliers[key] ?? 1;
+                        if (m > bestM) {
+                            bestM = m;
+                            best = key;
+                        }
+                    }
+                    if (best) {
+                        return best;
+                    }
+                    continue;
+                }
+                else if (isRecoveryAttempt) {
+                    const recovered = selectFirstAvailable(bucketCandidates);
+                    if (recovered)
+                        return recovered;
+                    continue;
+                }
                 const selected = deps.loadBalancer.select({
-                    routeName: `${routeName}:${tier.id}`,
+                    routeName: `${routeName}:${tier.id}:priority:${priority}`,
                     candidates: bucketCandidates,
                     stickyKey: options.allowAliasRotation ? undefined : stickyKey,
+                    weights: bucketWeights,
                     availabilityCheck: (key) => deps.healthManager.isAvailable(key)
-                }, tier.mode === 'round-robin' ? 'round-robin' : undefined);
-                if (selected) {
-                    return selected;
-                }
-            }
-        }
-        // default 路由永不因 quota gating 而“空池”：
-        // 当 quotaView 过滤后没有任何可用候选时，默认路由允许忽略 quotaView，
-        // 继续按健康/负载均衡选择一个 providerKey（但不覆盖 forced/required 约束）。
-        const quotaBypassAllowed = routeName === DEFAULT_ROUTE && (!requiredProviderKeys || requiredProviderKeys.size === 0);
-        if (quotaBypassAllowed) {
-            if (tier.mode === 'priority') {
-                const selected = selectFirstAvailable(candidates);
+                }, 'round-robin');
                 if (selected) {
                     return selected;
                 }
             }
             else {
+                if (isRecoveryAttempt && healthWeightedCfg.enabled && healthWeightedCfg.recoverToBestOnRetry) {
+                    let best = null;
+                    let bestM = Number.NEGATIVE_INFINITY;
+                    for (const key of bucketCandidates) {
+                        if (!deps.healthManager.isAvailable(key))
+                            continue;
+                        const m = bucketMultipliers[key] ?? 1;
+                        if (m > bestM) {
+                            bestM = m;
+                            best = key;
+                        }
+                    }
+                    if (best) {
+                        return best;
+                    }
+                    continue;
+                }
+                else if (isRecoveryAttempt) {
+                    const recovered = selectFirstAvailable(bucketCandidates);
+                    if (recovered)
+                        return recovered;
+                    continue;
+                }
                 const selected = deps.loadBalancer.select({
-                    routeName: `${routeName}:${tier.id}:quota-bypass`,
-                    candidates,
+                    routeName: `${routeName}:${tier.id}`,
+                    candidates: bucketCandidates,
                     stickyKey: options.allowAliasRotation ? undefined : stickyKey,
+                    weights: bucketWeights,
                     availabilityCheck: (key) => deps.healthManager.isAvailable(key)
                 }, tier.mode === 'round-robin' ? 'round-robin' : undefined);
                 if (selected) {
@@ -499,10 +594,6 @@ function trySelectFromTier(routeName, tier, stickyKey, estimatedTokens, features
                 }
             }
         }
-        // 单 provider 兜底：当只剩一个候选 key 时，不因 quota/blacklist/cooldown 或健康状态过滤导致无 provider。
-        if (candidates.length === 1) {
-            return candidates[0];
-        }
         return null;
     };
     for (const candidatePool of prioritizedPools) {
@@ -802,7 +893,6 @@ function buildContextCandidatePools(result) {
     const ordered = [];
     if (result.safe.length) {
         ordered.push(result.safe);
-        return ordered;
     }
     if (result.risky.length) {
         ordered.push(result.risky);

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

@@ -5,6 +5,7 @@ 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;
 }
 export declare class VirtualRouterEngine {
     private routing;
@@ -63,9 +64,11 @@ export declare class VirtualRouterEngine {
     private providerHealthConfig;
     private resolveStickyKey;
     private resolveSessionScope;
+    private resolveStopMessageScope;
     private getRoutingInstructionState;
     private buildMetadataInstructions;
     private parseMetadataDisableDescriptor;
+    private parseMetadataForceProviderKey;
     private resolveRoutingMode;
     private resolveInstructionTarget;
     private filterCandidatesByRoutingState;

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

@@ -7,10 +7,11 @@ import { ContextAdvisor } from './context-advisor.js';
 import { DEFAULT_ROUTE, ROUTE_PRIORITY, VirtualRouterError, VirtualRouterErrorCode } from './types.js';
 import { getStatsCenter } from '../../telemetry/stats-center.js';
 import { parseRoutingInstructions, applyRoutingInstructions, cleanMessagesFromRoutingInstructions } from './routing-instructions.js';
-import { loadRoutingInstructionStateSync, saveRoutingInstructionStateAsync } from './sticky-session-store.js';
+import { loadRoutingInstructionStateSync, saveRoutingInstructionStateAsync, saveRoutingInstructionStateSync } from './sticky-session-store.js';
 import { buildHitReason, formatVirtualRouterHit } from './engine-logging.js';
 import { selectDirectProviderModel, selectFromStickyPool, selectProviderImpl } from './engine-selection.js';
 import { applyQuotaDepletedImpl, applyQuotaRecoveryImpl, applySeriesCooldownImpl, handleProviderFailureImpl, mapProviderErrorImpl } from './engine-health.js';
+import { mergeStopMessageFromPersisted } from './stop-message-state-sync.js';
 export class VirtualRouterEngine {
     routing = {};
     providerRegistry = new ProviderRegistry();
@@ -29,7 +30,8 @@ export class VirtualRouterEngine {
     healthStore;
     routingStateStore = {
         loadSync: loadRoutingInstructionStateSync,
-        saveAsync: saveRoutingInstructionStateAsync
+        saveAsync: saveRoutingInstructionStateAsync,
+        saveSync: saveRoutingInstructionStateSync
     };
     routingInstructionState = new Map();
     quotaView;
@@ -56,7 +58,8 @@ export class VirtualRouterEngine {
                 deps.routingStateStore ??
                     {
                         loadSync: loadRoutingInstructionStateSync,
-                        saveAsync: saveRoutingInstructionStateAsync
+                        saveAsync: saveRoutingInstructionStateAsync,
+                        saveSync: saveRoutingInstructionStateSync
                     };
             // Routing state store changes require clearing in-memory cache to avoid stale reads.
             this.routingInstructionState.clear();
@@ -106,6 +109,7 @@ export class VirtualRouterEngine {
     route(request, metadata) {
         const stickyKey = this.resolveStickyKey(metadata);
         const sessionScope = this.resolveSessionScope(metadata);
+        const stopMessageScope = this.resolveStopMessageScope(metadata);
         // Routing instructions should be session/conversation-scoped when available (including /v1/responses),
         // while auto-sticky for Responses remains request-chain scoped via resolveStickyKey().
         const stateKey = sessionScope || stickyKey || 'default';
@@ -125,8 +129,8 @@ export class VirtualRouterEngine {
                 preferTarget: undefined
             };
         }
-        if (sessionScope) {
-            const sessionState = this.getRoutingInstructionState(sessionScope);
+        if (stopMessageScope) {
+            const sessionState = this.getRoutingInstructionState(stopMessageScope);
             if (typeof sessionState.stopMessageText === 'string' ||
                 typeof sessionState.stopMessageMaxRepeats === 'number') {
                 routingState = {
@@ -141,8 +145,8 @@ export class VirtualRouterEngine {
         }
         const parsedInstructions = parseRoutingInstructions(request.messages);
         let instructions = parsedInstructions;
-        if (sessionScope && parsedInstructions.length > 0) {
-            const sessionState = this.getRoutingInstructionState(sessionScope);
+        if (stopMessageScope && parsedInstructions.length > 0) {
+            const sessionState = this.getRoutingInstructionState(stopMessageScope);
             const hasStopMessageClear = parsedInstructions.some((entry) => entry.type === 'stopMessageClear');
             const stopMessageSets = parsedInstructions.filter((entry) => entry.type === 'stopMessageSet');
             if (!hasStopMessageClear && stopMessageSets.length > 0) {
@@ -162,6 +166,14 @@ export class VirtualRouterEngine {
                 }
             }
         }
+        // stopMessage must be session-scoped: require explicit sessionId in metadata.
+        // This prevents global/default persistence and ensures the trigger matches the setting sessionId.
+        if (parsedInstructions.length > 0) {
+            const hasStopMessageInstruction = parsedInstructions.some((entry) => entry.type === 'stopMessageSet' || entry.type === 'stopMessageClear');
+            if (hasStopMessageInstruction && !stopMessageScope) {
+                throw new VirtualRouterError('[stopMessage] requires sessionId (e.g. set x-session-id header or metadata.sessionId).', VirtualRouterErrorCode.CONFIG_ERROR, { requestId: metadata.requestId, entryEndpoint: metadata.entryEndpoint });
+            }
+        }
         if (parsedInstructions.length > 0) {
             request.messages = cleanMessagesFromRoutingInstructions(request.messages);
         }
@@ -171,21 +183,25 @@ export class VirtualRouterEngine {
             this.persistRoutingInstructionState(stateKey, routingState);
             // 对 stopMessage 指令补充一份基于 session/conversation 的持久化状态，
             // 便于 server-side 工具通过 session:*/conversation:* scope 读取到相同配置。
-            if (sessionScope) {
+            // stopMessage is strictly session-scoped (sessionId only). Persist it under the session scope
+            // so servertool triggers always match the setting sessionId.
+            if (stopMessageScope) {
                 const hasStopMessageSet = instructions.some((entry) => entry.type === 'stopMessageSet');
                 const hasStopMessageClear = instructions.some((entry) => entry.type === 'stopMessageClear');
                 if (hasStopMessageSet || hasStopMessageClear) {
-                    const sessionState = this.getRoutingInstructionState(sessionScope);
+                    const sessionState = this.getRoutingInstructionState(stopMessageScope);
                     let nextSessionState = {
                         ...sessionState
                     };
                     let shouldPersistSessionState = false;
                     if (hasStopMessageClear) {
+                        const clearedAt = Date.now();
                         nextSessionState.stopMessageText = undefined;
                         nextSessionState.stopMessageMaxRepeats = undefined;
                         nextSessionState.stopMessageUsed = undefined;
-                        nextSessionState.stopMessageUpdatedAt = undefined;
-                        nextSessionState.stopMessageLastUsedAt = undefined;
+                        nextSessionState.stopMessageUpdatedAt = clearedAt;
+                        nextSessionState.stopMessageLastUsedAt = clearedAt;
+                        nextSessionState.stopMessageSource = undefined;
                         shouldPersistSessionState = true;
                     }
                     else if (hasStopMessageSet) {
@@ -210,8 +226,8 @@ export class VirtualRouterEngine {
                         }
                     }
                     if (shouldPersistSessionState) {
-                        this.routingInstructionState.set(sessionScope, nextSessionState);
-                        this.persistRoutingInstructionState(sessionScope, nextSessionState);
+                        this.routingInstructionState.set(stopMessageScope, nextSessionState);
+                        this.persistRoutingInstructionState(stopMessageScope, nextSessionState);
                     }
                     else {
                         nextSessionState = sessionState;
@@ -228,8 +244,8 @@ export class VirtualRouterEngine {
                 }
             }
         }
-        if (instructions.length === 0 && sessionScope) {
-            const sessionState = this.getRoutingInstructionState(sessionScope);
+        if (instructions.length === 0 && stopMessageScope) {
+            const sessionState = this.getRoutingInstructionState(stopMessageScope);
             if (typeof sessionState.stopMessageText === 'string' ||
                 typeof sessionState.stopMessageMaxRepeats === 'number') {
                 routingState.stopMessageText = sessionState.stopMessageText;
@@ -709,6 +725,13 @@ export class VirtualRouterEngine {
         }
         return undefined;
     }
+    resolveStopMessageScope(metadata) {
+        const sessionId = typeof metadata.sessionId === 'string' ? metadata.sessionId.trim() : '';
+        if (sessionId) {
+            return `session:${sessionId}`;
+        }
+        return undefined;
+    }
     getRoutingInstructionState(stickyKey) {
         const key = stickyKey || 'default';
         const existing = this.routingInstructionState.get(key);
@@ -718,22 +741,13 @@ export class VirtualRouterEngine {
         if (existing && (key.startsWith('session:') || key.startsWith('conversation:'))) {
             try {
                 const persisted = this.routingStateStore.loadSync(key);
-                if (persisted) {
-                    // 以持久化状态为准（包括清空后的 undefined），避免 stopMessage 状态“卡死”在内存中。
-                    existing.stopMessageText = persisted.stopMessageText;
-                    existing.stopMessageMaxRepeats = persisted.stopMessageMaxRepeats;
-                    existing.stopMessageUsed = persisted.stopMessageUsed;
-                    existing.stopMessageUpdatedAt = persisted.stopMessageUpdatedAt;
-                    existing.stopMessageLastUsedAt = persisted.stopMessageLastUsedAt;
-                }
-                else {
-                    // 文件被删除或无法解析时，将内存中的 stopMessage 状态一并清空。
-                    existing.stopMessageText = undefined;
-                    existing.stopMessageMaxRepeats = undefined;
-                    existing.stopMessageUsed = undefined;
-                    existing.stopMessageUpdatedAt = undefined;
-                    existing.stopMessageLastUsedAt = undefined;
-                }
+                const merged = mergeStopMessageFromPersisted(existing, persisted);
+                existing.stopMessageSource = merged.stopMessageSource;
+                existing.stopMessageText = merged.stopMessageText;
+                existing.stopMessageMaxRepeats = merged.stopMessageMaxRepeats;
+                existing.stopMessageUsed = merged.stopMessageUsed;
+                existing.stopMessageUpdatedAt = merged.stopMessageUpdatedAt;
+                existing.stopMessageLastUsedAt = merged.stopMessageLastUsedAt;
             }
             catch {
                 // 刷新失败不影响原有内存状态
@@ -753,6 +767,7 @@ export class VirtualRouterEngine {
                 disabledProviders: new Set(),
                 disabledKeys: new Map(),
                 disabledModels: new Map(),
+                stopMessageSource: undefined,
                 stopMessageText: undefined,
                 stopMessageMaxRepeats: undefined,
                 stopMessageUsed: undefined,
@@ -765,6 +780,12 @@ export class VirtualRouterEngine {
     }
     buildMetadataInstructions(metadata) {
         const instructions = [];
+        const forcedProviderKeyRaw = metadata
+            .__shadowCompareForcedProviderKey;
+        const forcedProviderKey = this.parseMetadataForceProviderKey(forcedProviderKeyRaw);
+        if (forcedProviderKey) {
+            instructions.push({ type: 'force', ...forcedProviderKey });
+        }
         if (Array.isArray(metadata.disabledProviderKeyAliases)) {
             for (const entry of metadata.disabledProviderKeyAliases) {
                 const parsed = this.parseMetadataDisableDescriptor(entry);
@@ -797,6 +818,76 @@ export class VirtualRouterEngine {
         }
         return { provider, keyAlias: alias };
     }
+    parseMetadataForceProviderKey(entry) {
+        if (typeof entry !== 'string') {
+            return null;
+        }
+        const trimmed = entry.trim();
+        if (!trimmed) {
+            return null;
+        }
+        // Accept the bracket notation used in virtual-router-hit logs: provider[alias].model
+        // - provider[].model means provider.model across all aliases
+        const bracketMatch = trimmed.match(/^([a-zA-Z0-9_-]+)\[([a-zA-Z0-9_-]*)\](?:\.(.+))?$/);
+        if (bracketMatch) {
+            const provider = bracketMatch[1]?.trim() || '';
+            const keyAlias = bracketMatch[2]?.trim() || '';
+            const model = typeof bracketMatch[3] === 'string' ? bracketMatch[3].trim() : '';
+            if (!provider) {
+                return null;
+            }
+            if (keyAlias) {
+                return {
+                    provider,
+                    keyAlias,
+                    ...(model ? { model } : {}),
+                    pathLength: 3
+                };
+            }
+            if (model) {
+                return {
+                    provider,
+                    model,
+                    pathLength: 2
+                };
+            }
+            return { provider, pathLength: 1 };
+        }
+        // Accept provider.keyAlias.model and provider.model (model may contain dots when keyAlias is explicit).
+        const parts = trimmed.split('.').map((part) => part.trim()).filter(Boolean);
+        if (parts.length === 0) {
+            return null;
+        }
+        const provider = parts[0] || '';
+        if (!provider) {
+            return null;
+        }
+        if (parts.length === 1) {
+            return { provider, pathLength: 1 };
+        }
+        if (parts.length === 2) {
+            const second = parts[1] || '';
+            if (!second) {
+                return null;
+            }
+            if (/^\d+$/.test(second)) {
+                const keyIndex = Number.parseInt(second, 10);
+                return Number.isFinite(keyIndex) && keyIndex > 0 ? { provider, keyIndex, pathLength: 2 } : null;
+            }
+            return { provider, model: second, pathLength: 2 };
+        }
+        const keyAlias = parts[1] || '';
+        const model = parts.slice(2).join('.').trim();
+        if (!keyAlias) {
+            return null;
+        }
+        return {
+            provider,
+            keyAlias,
+            ...(model ? { model } : {}),
+            pathLength: 3
+        };
+    }
     resolveRoutingMode(instructions, state) {
         const hasForce = instructions.some((inst) => inst.type === 'force');
         const hasAllow = instructions.some((inst) => inst.type === 'allow');
@@ -1281,11 +1372,29 @@ export class VirtualRouterEngine {
         if (!key || (!key.startsWith('session:') && !key.startsWith('conversation:'))) {
             return;
         }
+        const supportsSync = typeof this.routingStateStore.saveSync === 'function';
+        const prefersSync = supportsSync &&
+            key.startsWith('session:') &&
+            (Boolean(state.stopMessageText && state.stopMessageText.trim()) ||
+                (typeof state.stopMessageMaxRepeats === 'number' && Number.isFinite(state.stopMessageMaxRepeats)) ||
+                (typeof state.stopMessageUsed === 'number' && Number.isFinite(state.stopMessageUsed)) ||
+                (typeof state.stopMessageUpdatedAt === 'number' && Number.isFinite(state.stopMessageUpdatedAt)) ||
+                (typeof state.stopMessageLastUsedAt === 'number' && Number.isFinite(state.stopMessageLastUsedAt)));
         if (this.isRoutingStateEmpty(state)) {
-            this.routingStateStore.saveAsync(key, null);
+            if (prefersSync) {
+                this.routingStateStore.saveSync(key, null);
+            }
+            else {
+                this.routingStateStore.saveAsync(key, null);
+            }
             return;
         }
-        this.routingStateStore.saveAsync(key, state);
+        if (prefersSync) {
+            this.routingStateStore.saveSync(key, state);
+        }
+        else {
+            this.routingStateStore.saveAsync(key, state);
+        }
     }
     markProviderCooldown(providerKey, cooldownMs) {
         if (!providerKey) {

package/dist/router/virtual-router/health-weighted.d.ts

@@ -0,0 +1,25 @@
+import type { HealthWeightedLoadBalancingConfig, ProviderQuotaViewEntry } from './types.js';
+export type ResolvedHealthWeightedConfig = Required<{
+    enabled: boolean;
+    baseWeight: number;
+    minMultiplier: number;
+    beta: number;
+    halfLifeMs: number;
+    recoverToBestOnRetry: boolean;
+}>;
+/**
+ * AWRR constant table (defaults).
+ *
+ * Notes:
+ * - `minMultiplier=0.5` is the "50% of baseline share" floor: penalties will not reduce a key below ~half of
+ *   its initial (equal) share within the same pool bucket.
+ * - `halfLifeMs=10min` means: if no new errors occur, the effect of the last error decays by 50% every 10 minutes.
+ * - `beta` controls how quickly errors reduce share; tune carefully.
+ */
+export declare const DEFAULT_HEALTH_WEIGHTED_CONFIG: ResolvedHealthWeightedConfig;
+export declare function resolveHealthWeightedConfig(raw?: HealthWeightedLoadBalancingConfig | null): ResolvedHealthWeightedConfig;
+export declare function computeHealthMultiplier(entry: ProviderQuotaViewEntry | null, nowMs: number, cfg: ResolvedHealthWeightedConfig): number;
+export declare function computeHealthWeight(entry: ProviderQuotaViewEntry | null, nowMs: number, cfg: ResolvedHealthWeightedConfig): {
+    weight: number;
+    multiplier: number;
+};

package/dist/router/virtual-router/health-weighted.js

@@ -0,0 +1,63 @@
+/**
+ * AWRR constant table (defaults).
+ *
+ * Notes:
+ * - `minMultiplier=0.5` is the "50% of baseline share" floor: penalties will not reduce a key below ~half of
+ *   its initial (equal) share within the same pool bucket.
+ * - `halfLifeMs=10min` means: if no new errors occur, the effect of the last error decays by 50% every 10 minutes.
+ * - `beta` controls how quickly errors reduce share; tune carefully.
+ */
+export const DEFAULT_HEALTH_WEIGHTED_CONFIG = {
+    enabled: false,
+    baseWeight: 100,
+    minMultiplier: 0.5,
+    beta: 0.1,
+    halfLifeMs: 10 * 60 * 1000,
+    recoverToBestOnRetry: true
+};
+export function resolveHealthWeightedConfig(raw) {
+    const enabled = raw?.enabled ?? DEFAULT_HEALTH_WEIGHTED_CONFIG.enabled;
+    const baseWeight = typeof raw?.baseWeight === 'number' && Number.isFinite(raw.baseWeight) && raw.baseWeight > 0
+        ? Math.floor(raw.baseWeight)
+        : DEFAULT_HEALTH_WEIGHTED_CONFIG.baseWeight;
+    const minMultiplier = typeof raw?.minMultiplier === 'number' && Number.isFinite(raw.minMultiplier) && raw.minMultiplier > 0
+        ? Math.min(1, raw.minMultiplier)
+        : DEFAULT_HEALTH_WEIGHTED_CONFIG.minMultiplier;
+    const beta = typeof raw?.beta === 'number' && Number.isFinite(raw.beta) && raw.beta >= 0
+        ? raw.beta
+        : DEFAULT_HEALTH_WEIGHTED_CONFIG.beta;
+    const halfLifeMs = typeof raw?.halfLifeMs === 'number' && Number.isFinite(raw.halfLifeMs) && raw.halfLifeMs > 0
+        ? Math.floor(raw.halfLifeMs)
+        : DEFAULT_HEALTH_WEIGHTED_CONFIG.halfLifeMs;
+    const recoverToBestOnRetry = raw?.recoverToBestOnRetry ?? DEFAULT_HEALTH_WEIGHTED_CONFIG.recoverToBestOnRetry;
+    return {
+        enabled,
+        baseWeight,
+        minMultiplier,
+        beta,
+        halfLifeMs,
+        recoverToBestOnRetry
+    };
+}
+export function computeHealthMultiplier(entry, nowMs, cfg) {
+    if (!entry) {
+        return 1;
+    }
+    const lastErrorAtMs = typeof entry.lastErrorAtMs === 'number' && Number.isFinite(entry.lastErrorAtMs) ? entry.lastErrorAtMs : null;
+    const consecutiveErrorCount = typeof entry.consecutiveErrorCount === 'number' && Number.isFinite(entry.consecutiveErrorCount) && entry.consecutiveErrorCount > 0
+        ? Math.floor(entry.consecutiveErrorCount)
+        : 0;
+    if (!lastErrorAtMs || consecutiveErrorCount <= 0) {
+        return 1;
+    }
+    const elapsedMs = Math.max(0, nowMs - lastErrorAtMs);
+    const decay = Math.exp((-Math.log(2) * elapsedMs) / cfg.halfLifeMs);
+    const effectiveErrors = consecutiveErrorCount * decay;
+    const raw = 1 - cfg.beta * effectiveErrors;
+    return Math.max(cfg.minMultiplier, Math.min(1, raw));
+}
+export function computeHealthWeight(entry, nowMs, cfg) {
+    const multiplier = computeHealthMultiplier(entry, nowMs, cfg);
+    const weight = Math.max(1, Math.round(cfg.baseWeight * multiplier));
+    return { weight, multiplier };
+}