@jsonstudio/llms 0.6.631 → 0.6.743

package/dist/filters/utils/snapshot-writer.js

@@ -13,22 +13,60 @@ function isSnapshotEnabled() {
     const v = String(process?.env?.RCC_FILTER_SNAPSHOT || process?.env?.RCC_HOOKS_VERBOSITY || '').toLowerCase();
     return v === '1' || v === 'true' || v === 'verbose';
 }
+function sanitizeToken(value, fallback) {
+    if (typeof value !== 'string') {
+        return fallback;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return fallback;
+    }
+    return trimmed.replace(/[^A-Za-z0-9_.-]/g, '_') || fallback;
+}
+function toErrorCode(error) {
+    if (!error || typeof error !== 'object') {
+        return undefined;
+    }
+    const code = error.code;
+    return typeof code === 'string' && code.trim() ? code : undefined;
+}
+async function writeUniqueFile(dir, baseName, contents) {
+    const parsed = path.parse(baseName);
+    const ext = parsed.ext || '.json';
+    const stem = parsed.name || 'snapshot';
+    for (let i = 0; i < 64; i += 1) {
+        const name = i === 0 ? `${stem}${ext}` : `${stem}_${i}${ext}`;
+        try {
+            await fsp.writeFile(path.join(dir, name), contents, { encoding: 'utf-8', flag: 'wx' });
+            return;
+        }
+        catch (error) {
+            if (toErrorCode(error) === 'EEXIST') {
+                continue;
+            }
+            throw error;
+        }
+    }
+    const fallback = `${stem}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}${ext}`;
+    await fsp.writeFile(path.join(dir, fallback), contents, 'utf-8');
+}
 export async function writeFilterSnapshot(options) {
     try {
         if (!isSnapshotEnabled())
             return;
-        const rid = options.requestId || `req_${Date.now()}`;
+        const rid = sanitizeToken(options.requestId || '', `req_${Date.now()}`);
         const baseOverride = process?.env?.RCC_SNAPSHOT_DIR;
         const base = baseOverride && baseOverride.trim()
             ? baseOverride.trim()
             : path.join(os.homedir(), '.routecodex', 'codex-samples');
         const folder = mapEndpointToFolder(options.endpoint);
-        const dir = path.join(base, folder);
+        const provider = sanitizeToken(options.profile || '', '__pending__');
+        const dir = path.join(base, folder, provider, rid);
         await fsp.mkdir(dir, { recursive: true });
         const parts = ['filters', options.stage.replace(/\s+/g, ''), options.tag || (options.name ? `after_${options.name}` : 'after')]
             .filter(Boolean)
             .join('_');
-        const file = path.join(dir, `${rid}_${parts}.json`);
+        const file = `${sanitizeToken(parts, 'filters')}.json`;
         const payload = {
             meta: {
                 requestId: rid,
@@ -41,7 +79,7 @@ export async function writeFilterSnapshot(options) {
             },
             data: options.data
         };
-        await fsp.writeFile(file, JSON.stringify(payload, null, 2), 'utf-8');
+        await writeUniqueFile(dir, file, JSON.stringify(payload, null, 2));
     }
     catch { /* ignore snapshot errors */ }
 }

package/dist/guidance/index.js

@@ -66,7 +66,9 @@ function augmentApplyPatch(fn) {
         'Each change describes one operation, e.g. `{ "file": "src/foo.ts", "kind": "insert_after", "anchor": "const foo = 1;", "lines": ["const bar = 2;"] }`.',
         'Supported kinds: insert_after, insert_before, replace, delete, create_file, delete_file.',
         'Paths must stay relative to the workspace root (no leading "/" or drive letters).',
-        'Insert operations require `anchor` text; replace/delete require exact `target` snippets; `lines` omit "+/-" prefixes.'
+        'Insert operations require `anchor` text; replace/delete require exact `target` snippets; `lines` omit "+/-" prefixes.',
+        'If you must emit raw patch text, use "*** Begin Patch" / "*** End Patch" with "*** Update/Add/Delete File" headers (no "diff --git").',
+        'Do not output "*** Create File:"; use "*** Add File:".'
     ].join('\n');
     const params = ensureObjectSchema(fn.parameters);
     const props = params.properties;
@@ -230,7 +232,10 @@ export function augmentAnthropicTools(tools) {
                         'Before using apply_patch, always read the latest content of the target file (via shell or another tool) and base your changes on that content.',
                         'Provide structured changes (insert_after / insert_before / replace / delete / create_file / delete_file) instead of raw patch text.',
                         'Each change must include the target file (relative path) plus anchor/target snippets and the replacement lines.',
-                        '所有路径必须相对工作区根目录，禁止输出以 / 或盘符开头的绝对路径。'
+                        '所有路径必须相对工作区根目录，禁止输出以 / 或盘符开头的绝对路径。',
+                        'Example: {\"changes\":[{\"file\":\"src/app.ts\",\"kind\":\"replace\",\"target\":\"const answer = 41;\",\"lines\":[\"const answer = 42;\"]}]}（修改同一文件时尽量只修改一段连续区域，多处不相邻修改请拆成多次 apply_patch 调用）.',
+                        'Raw patch text must use "*** Begin Patch" / "*** End Patch" + "*** Update/Add/Delete File" headers（不要输出 "diff --git"）。',
+                        '不要输出 "*** Create File:"；请使用 "*** Add File:".'
                     ].join('\n');
                     copy.description = appendOnce(desc, guidance, marker);
                 }
@@ -267,6 +272,7 @@ export function buildSystemToolGuidance() {
     lines.push(bullet('File writes are FORBIDDEN via shell (no redirection, no here-doc, no sed -i, no ed -s, no tee). Use apply_patch ONLY. / 通过 shell 写文件一律禁止（不得使用重定向、heredoc、sed -i、ed -s、tee）；必须使用 apply_patch。'));
     lines.push(bullet('apply_patch: Before writing, always read the target file first and compute changes against the latest content using appropriate tools. / apply_patch 在写入前必须先通过合适的工具读取目标文件最新内容，并基于该内容生成变更。'));
     lines.push(bullet('apply_patch: Provide structured JSON arguments with a `changes` array (insert_after / insert_before / replace / delete / create_file / delete_file); omit "+/-" prefixes in `lines`; file paths必须是相对路径。 / apply_patch 仅接受结构化 JSON。'));
+    lines.push(bullet('apply_patch: For a given file, prefer one contiguous change block per call; if you need to touch non-adjacent regions, split them into multiple apply_patch calls. / apply_patch 修改同一文件时尽量只提交一段连续补丁，多个不相邻位置请拆成多次调用。'));
     lines.push(bullet('update_plan: Keep exactly one step in_progress; others pending/completed. / 仅一个 in_progress 步骤。'));
     lines.push(bullet('view_image: Path must be an image file (.png .jpg .jpeg .gif .webp .bmp .svg). / 仅图片路径。'));
     lines.push(bullet('Do NOT use view_image for text files (.md/.ts/.js/.json). Use shell: {"command":["cat","<path>"]}. / 文本文件请用 shell: cat。'));

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

@@ -275,10 +275,6 @@ export function applyQuotaRecoveryImpl(event, healthManager, clearProviderCooldo
         healthManager.recordSuccess(providerKey);
         resetRateLimitBackoffForProvider(providerKey);
         clearProviderCooldown(providerKey);
-        debug?.log?.('[virtual-router] quota recovery', {
-            providerKey,
-            reason: detail.reason
-        });
     }
     catch {
         // 恢复失败不得影响主路由流程

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

@@ -1,4 +1,4 @@
-import type { ClassificationResult, RoutePoolTier, RouterMetadataInput, RoutingFeatures } from './types.js';
+import type { ClassificationResult, RoutePoolTier, RouterMetadataInput, RoutingFeatures, ProviderQuotaView } from './types.js';
 import type { RoutingInstructionState } from './routing-instructions.js';
 import type { ContextAdvisor } from './context-advisor.js';
 import type { RouteLoadBalancer } from './load-balancer.js';
@@ -12,6 +12,7 @@ type SelectionDeps = {
     loadBalancer: RouteLoadBalancer;
     isProviderCoolingDown: (providerKey: string) => boolean;
     resolveStickyKey: (metadata: RouterMetadataInput) => string | undefined;
+    quotaView?: ProviderQuotaView;
 };
 export declare function selectProviderImpl(requestedRoute: string, metadata: RouterMetadataInput, classification: ClassificationResult, features: RoutingFeatures, activeState: RoutingInstructionState, deps: SelectionDeps, options?: {
     routingState?: RoutingInstructionState;

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

@@ -1,11 +1,32 @@
 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;
+    const quotaView = deps.quotaView;
+    const quotaNow = quotaView ? Date.now() : 0;
+    const isAllowedByQuota = (key) => {
+        if (!quotaView) {
+            return true;
+        }
+        const entry = quotaView(key);
+        if (!entry) {
+            return true;
+        }
+        if (!entry.inPool) {
+            return false;
+        }
+        if (entry.cooldownUntil && entry.cooldownUntil > quotaNow) {
+            return false;
+        }
+        if (entry.blacklistUntil && entry.blacklistUntil > quotaNow) {
+            return false;
+        }
+        return true;
+    };
     const excludedProviderKeys = extractExcludedProviderKeySet(features.metadata);
     const forcedResolution = state.forcedTarget ? resolveInstructionTarget(state.forcedTarget, deps.providerRegistry) : null;
     if (forcedResolution && forcedResolution.mode === 'exact') {
         const forcedKey = forcedResolution.keys[0];
-        if (!excludedProviderKeys.has(forcedKey) && !deps.isProviderCoolingDown(forcedKey)) {
+        if (!excludedProviderKeys.has(forcedKey) && !deps.isProviderCoolingDown(forcedKey) && isAllowedByQuota(forcedKey)) {
             return {
                 providerKey: forcedKey,
                 routeUsed: requestedRoute,
@@ -22,7 +43,8 @@ export function selectProviderImpl(requestedRoute, metadata, classification, fea
             const stickyKey = stickyResolution.keys[0];
             if (deps.healthManager.isAvailable(stickyKey) &&
                 !excludedProviderKeys.has(stickyKey) &&
-                !deps.isProviderCoolingDown(stickyKey)) {
+                !deps.isProviderCoolingDown(stickyKey) &&
+                isAllowedByQuota(stickyKey)) {
                 return {
                     providerKey: stickyKey,
                     routeUsed: requestedRoute,
@@ -34,7 +56,8 @@ export function selectProviderImpl(requestedRoute, metadata, classification, fea
         if (stickyResolution && stickyResolution.mode === 'filter' && stickyResolution.keys.length > 0) {
             const liveKeys = stickyResolution.keys.filter((key) => deps.healthManager.isAvailable(key) &&
                 !excludedProviderKeys.has(key) &&
-                !deps.isProviderCoolingDown(key));
+                !deps.isProviderCoolingDown(key) &&
+                isAllowedByQuota(key));
             if (liveKeys.length > 0) {
                 stickyKeySet = new Set(liveKeys);
             }
@@ -247,13 +270,62 @@ function trySelectFromTier(routeName, tier, stickyKey, estimatedTokens, features
     }
     const contextResult = deps.contextAdvisor.classify(targets, estimatedTokens, (key) => deps.providerRegistry.get(key));
     const prioritizedPools = buildContextCandidatePools(contextResult);
+    const quotaView = deps.quotaView;
+    const now = quotaView ? Date.now() : 0;
+    const selectWithQuota = (candidates) => {
+        if (!quotaView) {
+            return deps.loadBalancer.select({
+                routeName: `${routeName}:${tier.id}`,
+                candidates,
+                stickyKey: options.allowAliasRotation ? undefined : stickyKey,
+                availabilityCheck: (key) => deps.healthManager.isAvailable(key)
+            });
+        }
+        const buckets = new Map();
+        for (const key of candidates) {
+            const entry = quotaView(key);
+            if (!entry) {
+                const list = buckets.get(100) ?? [];
+                list.push(key);
+                buckets.set(100, list);
+                continue;
+            }
+            if (!entry.inPool) {
+                continue;
+            }
+            if (entry.cooldownUntil && entry.cooldownUntil > now) {
+                continue;
+            }
+            if (entry.blacklistUntil && entry.blacklistUntil > now) {
+                continue;
+            }
+            const tierPriority = typeof entry.priorityTier === 'number' && Number.isFinite(entry.priorityTier)
+                ? entry.priorityTier
+                : 100;
+            const list = buckets.get(tierPriority) ?? [];
+            list.push(key);
+            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) {
+                continue;
+            }
+            const selected = deps.loadBalancer.select({
+                routeName: `${routeName}:${tier.id}`,
+                candidates: bucketCandidates,
+                stickyKey: options.allowAliasRotation ? undefined : stickyKey,
+                availabilityCheck: (key) => deps.healthManager.isAvailable(key)
+            });
+            if (selected) {
+                return selected;
+            }
+        }
+        return null;
+    };
     for (const candidatePool of prioritizedPools) {
-        const providerKey = deps.loadBalancer.select({
-            routeName: `${routeName}:${tier.id}`,
-            candidates: candidatePool,
-            stickyKey: options.allowAliasRotation ? undefined : stickyKey,
-            availabilityCheck: (key) => deps.healthManager.isAvailable(key)
-        });
+        const providerKey = selectWithQuota(candidatePool);
         if (providerKey) {
             return { providerKey, poolTargets: tier.targets, tierId: tier.id };
         }
@@ -277,6 +349,26 @@ export function selectFromStickyPool(stickyKeySet, metadata, features, state, de
     ]));
     const disabledModels = new Map(Array.from(state.disabledModels.entries()).map(([provider, models]) => [provider, new Set(models)]));
     let candidates = Array.from(stickyKeySet).filter((key) => !deps.isProviderCoolingDown(key));
+    const quotaView = deps.quotaView;
+    const now = quotaView ? Date.now() : 0;
+    if (quotaView) {
+        candidates = candidates.filter((key) => {
+            const entry = quotaView(key);
+            if (!entry) {
+                return true;
+            }
+            if (!entry.inPool) {
+                return false;
+            }
+            if (entry.cooldownUntil && entry.cooldownUntil > now) {
+                return false;
+            }
+            if (entry.blacklistUntil && entry.blacklistUntil > now) {
+                return false;
+            }
+            return true;
+        });
+    }
     if (allowedProviders.size > 0) {
         candidates = candidates.filter((key) => {
             const providerId = extractProviderId(key);

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

@@ -1,6 +1,7 @@
-import { type RoutingDecision, type RoutingDiagnostics, type RouterMetadataInput, type VirtualRouterConfig, type TargetMetadata, type ProviderFailureEvent, type ProviderErrorEvent, type VirtualRouterHealthStore } from './types.js';
+import { type RoutingDecision, type RoutingDiagnostics, type StopMessageStateSnapshot, type RouterMetadataInput, type VirtualRouterConfig, type TargetMetadata, type ProviderFailureEvent, type ProviderErrorEvent, 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;
@@ -22,9 +23,11 @@ export declare class VirtualRouterEngine {
     private healthStore?;
     private routingStateStore;
     private routingInstructionState;
+    private quotaView?;
     constructor(deps?: {
         healthStore?: VirtualRouterHealthStore;
         routingStateStore?: RoutingInstructionStateStore;
+        quotaView?: ProviderQuotaView;
     });
     initialize(config: VirtualRouterConfig): void;
     route(request: StandardizedRequest | ProcessedRequest, metadata: RouterMetadataInput): {
@@ -32,6 +35,7 @@ export declare class VirtualRouterEngine {
         decision: RoutingDecision;
         diagnostics: RoutingDiagnostics;
     };
+    getStopMessageState(metadata: RouterMetadataInput): StopMessageStateSnapshot | null;
     handleProviderFailure(event: ProviderFailureEvent): void;
     handleProviderError(event: ProviderErrorEvent): void;
     getStatus(): {

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

@@ -32,6 +32,7 @@ export class VirtualRouterEngine {
         saveAsync: saveRoutingInstructionStateAsync
     };
     routingInstructionState = new Map();
+    quotaView;
     constructor(deps) {
         if (deps?.healthStore) {
             this.healthStore = deps.healthStore;
@@ -39,6 +40,9 @@ export class VirtualRouterEngine {
         if (deps?.routingStateStore) {
             this.routingStateStore = deps.routingStateStore;
         }
+        if (deps?.quotaView) {
+            this.quotaView = deps.quotaView;
+        }
     }
     initialize(config) {
         this.validateConfig(config);
@@ -76,13 +80,121 @@ export class VirtualRouterEngine {
                 stickyTarget: undefined
             };
         }
-        const instructions = parseRoutingInstructions(request.messages);
+        const sessionScope = this.resolveSessionScope(metadata);
+        if (sessionScope) {
+            const sessionState = this.getRoutingInstructionState(sessionScope);
+            if (typeof sessionState.stopMessageText === 'string' ||
+                typeof sessionState.stopMessageMaxRepeats === 'number') {
+                routingState = {
+                    ...routingState,
+                    stopMessageText: sessionState.stopMessageText,
+                    stopMessageMaxRepeats: sessionState.stopMessageMaxRepeats,
+                    stopMessageUsed: sessionState.stopMessageUsed,
+                    stopMessageUpdatedAt: sessionState.stopMessageUpdatedAt,
+                    stopMessageLastUsedAt: sessionState.stopMessageLastUsedAt
+                };
+            }
+        }
+        const parsedInstructions = parseRoutingInstructions(request.messages);
+        let instructions = parsedInstructions;
+        if (sessionScope && parsedInstructions.length > 0) {
+            const sessionState = this.getRoutingInstructionState(sessionScope);
+            const hasStopMessageClear = parsedInstructions.some((entry) => entry.type === 'stopMessageClear');
+            const stopMessageSets = parsedInstructions.filter((entry) => entry.type === 'stopMessageSet');
+            if (!hasStopMessageClear && stopMessageSets.length > 0) {
+                const sessionText = typeof sessionState.stopMessageText === 'string' ? sessionState.stopMessageText.trim() : '';
+                const sessionMax = typeof sessionState.stopMessageMaxRepeats === 'number' && Number.isFinite(sessionState.stopMessageMaxRepeats)
+                    ? Math.floor(sessionState.stopMessageMaxRepeats)
+                    : undefined;
+                const allSame = stopMessageSets.every((entry) => {
+                    const entryText = typeof entry.stopMessageText === 'string' ? entry.stopMessageText.trim() : '';
+                    const entryMax = typeof entry.stopMessageMaxRepeats === 'number' && Number.isFinite(entry.stopMessageMaxRepeats)
+                        ? Math.floor(entry.stopMessageMaxRepeats)
+                        : undefined;
+                    return Boolean(entryText) && entryText === sessionText && entryMax === sessionMax;
+                });
+                if (allSame) {
+                    instructions = parsedInstructions.filter((entry) => entry.type !== 'stopMessageSet');
+                }
+            }
+        }
+        if (parsedInstructions.length > 0) {
+            request.messages = cleanMessagesFromRoutingInstructions(request.messages);
+        }
         if (instructions.length > 0) {
             routingState = applyRoutingInstructions(instructions, routingState);
             const effectiveKey = stickyKey || 'default';
             this.routingInstructionState.set(effectiveKey, routingState);
-            request.messages = cleanMessagesFromRoutingInstructions(request.messages);
             this.persistRoutingInstructionState(effectiveKey, routingState);
+            // 对 stopMessage 指令补充一份基于 session/conversation 的持久化状态，
+            // 便于 server-side 工具通过 session:*/conversation:* scope 读取到相同配置。
+            if (sessionScope) {
+                const hasStopMessageSet = instructions.some((entry) => entry.type === 'stopMessageSet');
+                const hasStopMessageClear = instructions.some((entry) => entry.type === 'stopMessageClear');
+                if (hasStopMessageSet || hasStopMessageClear) {
+                    const sessionState = this.getRoutingInstructionState(sessionScope);
+                    let nextSessionState = {
+                        ...sessionState
+                    };
+                    let shouldPersistSessionState = false;
+                    if (hasStopMessageClear) {
+                        nextSessionState.stopMessageText = undefined;
+                        nextSessionState.stopMessageMaxRepeats = undefined;
+                        nextSessionState.stopMessageUsed = undefined;
+                        nextSessionState.stopMessageUpdatedAt = undefined;
+                        nextSessionState.stopMessageLastUsedAt = undefined;
+                        shouldPersistSessionState = true;
+                    }
+                    else if (hasStopMessageSet) {
+                        const text = typeof routingState.stopMessageText === 'string' ? routingState.stopMessageText : '';
+                        const maxRepeats = routingState.stopMessageMaxRepeats;
+                        const sameText = typeof sessionState.stopMessageText === 'string' &&
+                            sessionState.stopMessageText.trim() === text.trim();
+                        const sameMax = typeof sessionState.stopMessageMaxRepeats === 'number' &&
+                            typeof maxRepeats === 'number' &&
+                            Math.floor(sessionState.stopMessageMaxRepeats) === Math.floor(maxRepeats);
+                        const isSameInstruction = Boolean(text) && sameText && sameMax;
+                        nextSessionState.stopMessageText = text || undefined;
+                        nextSessionState.stopMessageMaxRepeats = maxRepeats;
+                        if (!isSameInstruction) {
+                            nextSessionState.stopMessageUsed = 0;
+                            nextSessionState.stopMessageUpdatedAt =
+                                typeof routingState.stopMessageUpdatedAt === 'number'
+                                    ? routingState.stopMessageUpdatedAt
+                                    : Date.now();
+                            nextSessionState.stopMessageLastUsedAt = undefined;
+                            shouldPersistSessionState = true;
+                        }
+                    }
+                    if (shouldPersistSessionState) {
+                        this.routingInstructionState.set(sessionScope, nextSessionState);
+                        this.persistRoutingInstructionState(sessionScope, nextSessionState);
+                    }
+                    else {
+                        nextSessionState = sessionState;
+                    }
+                    // 日志展示使用 session scope 的 stopMessage 状态，避免每次解析重复刷新时间/次数。
+                    if (typeof nextSessionState.stopMessageText === 'string' ||
+                        typeof nextSessionState.stopMessageMaxRepeats === 'number') {
+                        routingState.stopMessageText = nextSessionState.stopMessageText;
+                        routingState.stopMessageMaxRepeats = nextSessionState.stopMessageMaxRepeats;
+                        routingState.stopMessageUsed = nextSessionState.stopMessageUsed;
+                        routingState.stopMessageUpdatedAt = nextSessionState.stopMessageUpdatedAt;
+                        routingState.stopMessageLastUsedAt = nextSessionState.stopMessageLastUsedAt;
+                    }
+                }
+            }
+        }
+        if (instructions.length === 0 && sessionScope) {
+            const sessionState = this.getRoutingInstructionState(sessionScope);
+            if (typeof sessionState.stopMessageText === 'string' ||
+                typeof sessionState.stopMessageMaxRepeats === 'number') {
+                routingState.stopMessageText = sessionState.stopMessageText;
+                routingState.stopMessageMaxRepeats = sessionState.stopMessageMaxRepeats;
+                routingState.stopMessageUsed = sessionState.stopMessageUsed;
+                routingState.stopMessageUpdatedAt = sessionState.stopMessageUpdatedAt;
+                routingState.stopMessageLastUsedAt = sessionState.stopMessageLastUsedAt;
+            }
         }
         const routingMode = this.resolveRoutingMode([...metadataInstructions, ...instructions], routingState);
         const features = buildRoutingFeatures(request, metadata);
@@ -183,6 +295,44 @@ export class VirtualRouterEngine {
             }
         };
     }
+    getStopMessageState(metadata) {
+        const sessionScope = this.resolveSessionScope(metadata);
+        const sessionState = sessionScope ? this.getRoutingInstructionState(sessionScope) : null;
+        const stickyKey = this.resolveStickyKey(metadata);
+        const stickyState = stickyKey ? this.getRoutingInstructionState(stickyKey) : null;
+        const effectiveState = sessionState && typeof sessionState.stopMessageText === 'string' && sessionState.stopMessageText.trim()
+            ? sessionState
+            : stickyState;
+        if (!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;
+        if (!text || maxRepeats <= 0) {
+            return null;
+        }
+        return {
+            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 }
+                : {})
+        };
+    }
     handleProviderFailure(event) {
         handleProviderFailureImpl(event, this.healthManager, this.providerHealthConfig(), (key, ttl) => this.markProviderCooldown(key, ttl));
     }
@@ -195,6 +345,12 @@ export class VirtualRouterEngine {
                 // ignore persistence errors
             }
         }
+        // 当 Host 注入 quotaView 时，VirtualRouter 的入池/优先级决策应以 quota 为准；
+        // 此时不再在 engine-health 内部进行 429/backoff/series cooldown 等健康决策，
+        // 以避免与 daemon/quota-center 的长期熔断策略重复维护并导致日志噪声。
+        if (this.quotaView) {
+            return;
+        }
         // 配额恢复事件优先处理：一旦识别到 virtualRouterQuotaRecovery，
         // 直接清理健康状态/冷却 TTL，避免继续走常规错误映射逻辑。
         const handledByQuota = applyQuotaRecoveryImpl(event, this.healthManager, (key) => this.clearProviderCooldown(key), this.debug);
@@ -278,7 +434,8 @@ export class VirtualRouterEngine {
             contextAdvisor: this.contextAdvisor,
             loadBalancer: this.loadBalancer,
             isProviderCoolingDown: (key) => this.isProviderCoolingDown(key),
-            resolveStickyKey: (m) => this.resolveStickyKey(m)
+            resolveStickyKey: (m) => this.resolveStickyKey(m),
+            quotaView: this.quotaView
         }, { routingState });
     }
     incrementRouteStat(routeName, providerKey) {
@@ -327,8 +484,34 @@ export class VirtualRouterEngine {
     }
     getRoutingInstructionState(stickyKey) {
         const key = stickyKey || 'default';
-        if (this.routingInstructionState.has(key)) {
-            return this.routingInstructionState.get(key);
+        const existing = this.routingInstructionState.get(key);
+        // 对 session:/conversation: 作用域，在每次读取时尝试从磁盘刷新 stopMessage 相关字段，
+        // 确保 servertool（如 stop_message_auto）通过 sticky-session-store 更新的使用次数
+        // 能在 VirtualRouter 日志中实时反映出来。
+        if (existing && (key.startsWith('session:') || key.startsWith('conversation:'))) {
+            try {
+                const persisted = loadRoutingInstructionStateSync(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;
+                }
+            }
+            catch {
+                // 刷新失败不影响原有内存状态
+            }
+            return existing;
         }
         let initial = null;
         // 仅对 session:/conversation: 作用域的 key 尝试从磁盘恢复持久化状态

package/dist/router/virtual-router/routing-instructions.d.ts

@@ -28,6 +28,12 @@ export interface RoutingInstructionState {
     disabledProviders: Set<string>;
     disabledKeys: Map<string, Set<string | number>>;
     disabledModels: Map<string, Set<string>>;
+    /**
+     * Source of the current stopMessage configuration.
+     * - 'explicit'：由用户通过 <** stopMessage:"..." **> 指令显式设置
+     * - 'auto'：由系统基于空响应/错误自动推导（例如 Gemini 空回复）
+     */
+    stopMessageSource?: string;
     stopMessageText?: string;
     stopMessageMaxRepeats?: number;
     stopMessageUsed?: number;

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

@@ -398,11 +398,19 @@ export function applyRoutingInstructions(instructions, currentState) {
                     ? Math.floor(instruction.stopMessageMaxRepeats)
                     : 0;
                 if (text && maxRepeats > 0) {
+                    const sameText = typeof newState.stopMessageText === 'string' &&
+                        newState.stopMessageText.trim() === text;
+                    const sameMax = typeof newState.stopMessageMaxRepeats === 'number' &&
+                        Math.floor(newState.stopMessageMaxRepeats) === maxRepeats;
+                    const isSameInstruction = sameText && sameMax;
                     newState.stopMessageText = text;
                     newState.stopMessageMaxRepeats = maxRepeats;
-                    newState.stopMessageUsed = 0;
-                    newState.stopMessageUpdatedAt = Date.now();
-                    newState.stopMessageLastUsedAt = undefined;
+                    newState.stopMessageSource = 'explicit';
+                    if (!isSameInstruction) {
+                        newState.stopMessageUsed = 0;
+                        newState.stopMessageUpdatedAt = Date.now();
+                        newState.stopMessageLastUsedAt = undefined;
+                    }
                 }
                 break;
             }
@@ -410,6 +418,7 @@ export function applyRoutingInstructions(instructions, currentState) {
                 newState.stopMessageText = undefined;
                 newState.stopMessageMaxRepeats = undefined;
                 newState.stopMessageUsed = undefined;
+                newState.stopMessageSource = undefined;
                 newState.stopMessageUpdatedAt = undefined;
                 newState.stopMessageLastUsedAt = undefined;
                 break;
@@ -453,6 +462,9 @@ export function serializeRoutingInstructionState(state) {
             provider,
             models: Array.from(models)
         })),
+        ...(typeof state.stopMessageSource === 'string' && state.stopMessageSource.trim()
+            ? { stopMessageSource: state.stopMessageSource }
+            : {}),
         ...(typeof state.stopMessageText === 'string' && state.stopMessageText.trim()
             ? { stopMessageText: state.stopMessageText }
             : {}),
@@ -508,6 +520,9 @@ export function deserializeRoutingInstructionState(data) {
             }
         }
     }
+    if (typeof data.stopMessageSource === 'string' && data.stopMessageSource.trim()) {
+        state.stopMessageSource = data.stopMessageSource.trim();
+    }
     if (typeof data.stopMessageText === 'string' && data.stopMessageText.trim()) {
         state.stopMessageText = data.stopMessageText;
     }

package/dist/router/virtual-router/sticky-session-store.d.ts

@@ -1,3 +1,4 @@
 import type { RoutingInstructionState } from './routing-instructions.js';
 export declare function loadRoutingInstructionStateSync(key: string | undefined): RoutingInstructionState | null;
 export declare function saveRoutingInstructionStateAsync(key: string | undefined, state: RoutingInstructionState | null): void;
+export declare function saveRoutingInstructionStateSync(key: string | undefined, state: RoutingInstructionState | null): void;