@jsonstudio/llms 0.6.954 → 0.6.1172

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 };
+}

package/dist/router/virtual-router/load-balancer.d.ts

@@ -3,6 +3,7 @@ export interface LoadBalancingOptions {
     routeName: string;
     candidates: string[];
     stickyKey?: string;
+    weights?: Record<string, number>;
     availabilityCheck: (providerKey: string) => boolean;
 }
 export declare class RouteLoadBalancer {
@@ -10,6 +11,7 @@ export declare class RouteLoadBalancer {
     private readonly states;
     constructor(policy?: LoadBalancingPolicy);
     updatePolicy(policy?: LoadBalancingPolicy): void;
+    getPolicy(): LoadBalancingPolicy;
     select(options: LoadBalancingOptions, strategyOverride?: LoadBalancingPolicy['strategy']): string | null;
     private selectRoundRobin;
     private selectWeighted;

package/dist/router/virtual-router/load-balancer.js

@@ -9,6 +9,9 @@ export class RouteLoadBalancer {
             this.policy = policy;
         }
     }
+    getPolicy() {
+        return this.policy;
+    }
     select(options, strategyOverride) {
         const available = options.candidates.filter((candidate) => options.availabilityCheck(candidate));
         if (available.length === 0) {
@@ -17,10 +20,16 @@ export class RouteLoadBalancer {
         const strategy = strategyOverride ?? this.policy.strategy;
         switch (strategy) {
             case 'sticky':
-                return this.selectSticky(options.routeName, available, options.stickyKey);
+                return this.selectSticky(options.routeName, available, options.stickyKey, options.weights ?? this.policy.weights);
             case 'weighted':
-                return this.selectWeighted(available);
+                return this.selectWeighted(options.routeName, available, options.weights ?? this.policy.weights);
             default:
+                if (options.weights) {
+                    const distinct = new Set(available.map((candidate) => Math.max(1, options.weights?.[candidate] ?? 1)));
+                    if (distinct.size > 1) {
+                        return this.selectWeighted(options.routeName, available, options.weights);
+                    }
+                }
                 return this.selectRoundRobin(options.routeName, available);
         }
     }
@@ -30,23 +39,41 @@ export class RouteLoadBalancer {
         state.pointer = (state.pointer + 1) % candidates.length;
         return choice;
     }
-    selectWeighted(candidates) {
-        if (!this.policy.weights) {
-            return candidates[0];
+    selectWeighted(routeName, candidates, weights) {
+        // Deterministic smooth weighted round-robin (no randomness) so routing behavior is testable and stable.
+        // Each candidate with a positive weight is guaranteed to be selected eventually.
+        const state = this.getState(routeName);
+        const current = state.weighted.currentWeights;
+        const candidateSet = new Set(candidates);
+        for (const existing of Array.from(current.keys())) {
+            if (!candidateSet.has(existing)) {
+                current.delete(existing);
+            }
+        }
+        for (const key of candidates) {
+            if (!current.has(key)) {
+                current.set(key, 0);
+            }
         }
-        const weights = candidates.map((candidate) => Math.max(1, this.policy.weights?.[candidate] ?? 1));
-        const total = weights.reduce((sum, weight) => sum + weight, 0);
-        const threshold = Math.random() * total;
-        let running = 0;
+        const candidateWeights = candidates.map((candidate) => Math.max(1, weights?.[candidate] ?? 1));
+        const totalWeight = candidateWeights.reduce((sum, w) => sum + w, 0);
+        let bestIndex = 0;
+        let bestScore = Number.NEGATIVE_INFINITY;
         for (let i = 0; i < candidates.length; i += 1) {
-            running += weights[i];
-            if (running >= threshold) {
-                return candidates[i];
+            const key = candidates[i];
+            const w = candidateWeights[i];
+            const next = (current.get(key) ?? 0) + w;
+            current.set(key, next);
+            if (next > bestScore) {
+                bestScore = next;
+                bestIndex = i;
             }
         }
-        return candidates[candidates.length - 1];
+        const selectedKey = candidates[bestIndex];
+        current.set(selectedKey, (current.get(selectedKey) ?? 0) - totalWeight);
+        return selectedKey;
     }
-    selectSticky(routeName, candidates, stickyKey) {
+    selectSticky(routeName, candidates, stickyKey, weights) {
         if (!stickyKey) {
             return this.selectRoundRobin(routeName, candidates);
         }
@@ -55,13 +82,15 @@ export class RouteLoadBalancer {
         if (pinned && candidates.includes(pinned)) {
             return pinned;
         }
-        const choice = this.selectRoundRobin(routeName, candidates);
+        const choice = weights && Object.keys(weights).length > 0
+            ? this.selectWeighted(`${routeName}:sticky`, candidates, weights)
+            : this.selectRoundRobin(routeName, candidates);
         state.stickyMap.set(stickyKey, choice);
         return choice;
     }
     getState(routeName) {
         if (!this.states.has(routeName)) {
-            this.states.set(routeName, { pointer: 0, stickyMap: new Map() });
+            this.states.set(routeName, { pointer: 0, stickyMap: new Map(), weighted: { currentWeights: new Map() } });
         }
         return this.states.get(routeName);
     }

package/dist/router/virtual-router/routing-instructions.js

@@ -1,15 +1,21 @@
 import { extractMessageText } from './message-utils.js';
+import { resolveStopMessageText } from './stop-message-file-resolver.js';
 export function parseRoutingInstructions(messages) {
     const instructions = [];
     // 从最新一条携带路由指令标记（<** ... **>）的 user 消息中解析指令，
     // 而不是简单地取"最后一条 user 消息"。这样可以在服务重启后，通过完整
     // 会话历史恢复 sticky/黑名单状态，同时保持"最后一次指令生效"的语义。
     let sanitized = null;
+    let sanitizedIndex = -1;
+    let lastUserIndex = -1;
     for (let idx = messages.length - 1; idx >= 0; idx -= 1) {
         const message = messages[idx];
         if (!message || message.role !== 'user') {
             continue;
         }
+        if (lastUserIndex < 0) {
+            lastUserIndex = idx;
+        }
         const content = extractMessageText(message);
         if (!content) {
             continue;
@@ -22,6 +28,7 @@ export function parseRoutingInstructions(messages) {
             continue;
         }
         sanitized = candidate;
+        sanitizedIndex = idx;
         break;
     }
     if (!sanitized) {
@@ -38,6 +45,15 @@ export function parseRoutingInstructions(messages) {
         for (const segment of segments) {
             const parsed = parseSingleInstruction(segment);
             if (parsed) {
+                // stopMessage is a "command" and must only be set/cleared from the *latest* user message.
+                // Otherwise, clients that resend full history (including a past "<**stopMessage:...**>" message)
+                // would keep re-applying stopMessage after it has been consumed/cleared.
+                if ((parsed.type === 'stopMessageSet' || parsed.type === 'stopMessageClear') &&
+                    lastUserIndex >= 0 &&
+                    sanitizedIndex >= 0 &&
+                    sanitizedIndex !== lastUserIndex) {
+                    continue;
+                }
                 instructions.push(parsed);
             }
         }
@@ -176,7 +192,7 @@ function parseSingleInstruction(instruction) {
         }
         return {
             type: 'stopMessageSet',
-            stopMessageText: text,
+            stopMessageText: resolveStopMessageText(text),
             stopMessageMaxRepeats: maxRepeats
         };
     }