@jsonstudio/llms 0.6.633 → 0.6.749

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

@@ -9,7 +9,7 @@ import { getStatsCenter } from '../../telemetry/stats-center.js';
 import { parseRoutingInstructions, applyRoutingInstructions, cleanMessagesFromRoutingInstructions } from './routing-instructions.js';
 import { loadRoutingInstructionStateSync, saveRoutingInstructionStateAsync } from './sticky-session-store.js';
 import { buildHitReason, formatVirtualRouterHit } from './engine-logging.js';
-import { selectProviderImpl } from './engine-selection.js';
+import { selectDirectProviderModel, selectProviderImpl } from './engine-selection.js';
 import { applyQuotaDepletedImpl, applyQuotaRecoveryImpl, applySeriesCooldownImpl, handleProviderFailureImpl, mapProviderErrorImpl } from './engine-health.js';
 export class VirtualRouterEngine {
     routing = {};
@@ -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,28 @@ export class VirtualRouterEngine {
         if (deps?.routingStateStore) {
             this.routingStateStore = deps.routingStateStore;
         }
+        if (deps?.quotaView) {
+            this.quotaView = deps.quotaView;
+        }
+    }
+    parseDirectProviderModel(model) {
+        const raw = typeof model === 'string' ? model.trim() : '';
+        if (!raw) {
+            return null;
+        }
+        const firstDot = raw.indexOf('.');
+        if (firstDot <= 0 || firstDot === raw.length - 1) {
+            return null;
+        }
+        const providerId = raw.slice(0, firstDot).trim();
+        const modelId = raw.slice(firstDot + 1).trim();
+        if (!providerId || !modelId) {
+            return null;
+        }
+        if (this.providerRegistry.listProviderKeys(providerId).length === 0) {
+            return null;
+        }
+        return { providerId, modelId };
     }
     initialize(config) {
         this.validateConfig(config);
@@ -76,27 +99,182 @@ 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);
-        const classification = metadata.routeHint && metadata.routeHint.trim()
-            ? {
-                routeName: metadata.routeHint.trim(),
+        const directProviderModel = this.parseDirectProviderModel(request?.model);
+        let classification;
+        let requestedRoute;
+        let selection;
+        if (directProviderModel) {
+            const providerKeys = this.providerRegistry.listProviderKeys(directProviderModel.providerId);
+            let hasModel = false;
+            for (const key of providerKeys) {
+                try {
+                    const profile = this.providerRegistry.get(key);
+                    if (profile?.modelId === directProviderModel.modelId) {
+                        hasModel = true;
+                        break;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (!hasModel) {
+                throw new VirtualRouterError(`Unknown model ${directProviderModel.modelId} for provider ${directProviderModel.providerId}`, VirtualRouterErrorCode.CONFIG_ERROR, { providerId: directProviderModel.providerId, modelId: directProviderModel.modelId });
+            }
+            classification = {
+                routeName: 'direct',
                 confidence: 1,
-                reasoning: `route_hint:${metadata.routeHint.trim()}`,
+                reasoning: `direct_model:${directProviderModel.providerId}.${directProviderModel.modelId}`,
                 fallback: false,
-                candidates: [metadata.routeHint.trim()]
+                candidates: ['direct']
+            };
+            requestedRoute = 'direct';
+            const directSelection = selectDirectProviderModel(directProviderModel.providerId, directProviderModel.modelId, metadata, features, routingState, {
+                routing: this.routing,
+                providerRegistry: this.providerRegistry,
+                healthManager: this.healthManager,
+                contextAdvisor: this.contextAdvisor,
+                loadBalancer: this.loadBalancer,
+                isProviderCoolingDown: (key) => this.isProviderCoolingDown(key),
+                resolveStickyKey: (m) => this.resolveStickyKey(m),
+                quotaView: this.quotaView
+            });
+            if (!directSelection) {
+                throw new VirtualRouterError(`All providers unavailable for model ${directProviderModel.providerId}.${directProviderModel.modelId}`, VirtualRouterErrorCode.PROVIDER_NOT_AVAILABLE, { providerId: directProviderModel.providerId, modelId: directProviderModel.modelId });
             }
-            : this.classifier.classify(features);
-        const requestedRoute = this.normalizeRouteAlias(classification.routeName || DEFAULT_ROUTE);
-        const selection = this.selectProvider(requestedRoute, metadata, classification, features, routingState);
+            selection = directSelection;
+        }
+        else {
+            classification = metadata.routeHint && metadata.routeHint.trim()
+                ? {
+                    routeName: metadata.routeHint.trim(),
+                    confidence: 1,
+                    reasoning: `route_hint:${metadata.routeHint.trim()}`,
+                    fallback: false,
+                    candidates: [metadata.routeHint.trim()]
+                }
+                : this.classifier.classify(features);
+            requestedRoute = this.normalizeRouteAlias(classification.routeName || DEFAULT_ROUTE);
+            selection = this.selectProvider(requestedRoute, metadata, classification, features, routingState);
+        }
         const baseTarget = this.providerRegistry.buildTarget(selection.providerKey);
         const forceVision = this.routeHasForceFlag('vision');
         const target = {
@@ -183,6 +361,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 +411,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 +500,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 +550,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/load-balancer.d.ts

@@ -0,0 +1,18 @@
+import type { LoadBalancingPolicy } from './types.js';
+export interface LoadBalancingOptions {
+    routeName: string;
+    candidates: string[];
+    stickyKey?: string;
+    availabilityCheck: (providerKey: string) => boolean;
+}
+export declare class RouteLoadBalancer {
+    private policy;
+    private readonly states;
+    constructor(policy?: LoadBalancingPolicy);
+    updatePolicy(policy?: LoadBalancingPolicy): void;
+    select(options: LoadBalancingOptions, strategyOverride?: LoadBalancingPolicy['strategy']): string | null;
+    private selectRoundRobin;
+    private selectWeighted;
+    private selectSticky;
+    private getState;
+}

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

@@ -9,12 +9,13 @@ export class RouteLoadBalancer {
             this.policy = policy;
         }
     }
-    select(options) {
+    select(options, strategyOverride) {
         const available = options.candidates.filter((candidate) => options.availabilityCheck(candidate));
         if (available.length === 0) {
             return null;
         }
-        switch (this.policy.strategy) {
+        const strategy = strategyOverride ?? this.policy.strategy;
+        switch (strategy) {
             case 'sticky':
                 return this.selectSticky(options.routeName, available, options.stickyKey);
             case 'weighted':

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;

package/dist/router/virtual-router/sticky-session-store.js

@@ -108,3 +108,39 @@ export function saveRoutingInstructionStateAsync(key, state) {
         // ignore sync write failures
     }
 }
+export function saveRoutingInstructionStateSync(key, state) {
+    if (!isPersistentKey(key)) {
+        return;
+    }
+    const dir = resolveSessionDir();
+    const filename = keyToFilename(key);
+    if (!dir || !filename) {
+        return;
+    }
+    const filepath = path.join(dir, filename);
+    if (!state) {
+        try {
+            fs.unlinkSync(filepath);
+        }
+        catch {
+            // ignore unlink failures
+        }
+        return;
+    }
+    const payload = {
+        version: 1,
+        state: serializeRoutingInstructionState(state)
+    };
+    try {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    catch {
+        // ignore mkdir errors
+    }
+    try {
+        fs.writeFileSync(filepath, JSON.stringify(payload), { encoding: 'utf8' });
+    }
+    catch {
+        // ignore sync write failures
+    }
+}

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

@@ -6,10 +6,17 @@ export declare const DEFAULT_MODEL_CONTEXT_TOKENS = 200000;
 export declare const DEFAULT_ROUTE = "default";
 export declare const ROUTE_PRIORITY: string[];
 export type RoutingInstructionMode = 'force' | 'sticky' | 'none';
+export type RoutePoolMode = 'round-robin' | 'priority';
 export interface RoutePoolTier {
     id: string;
     targets: string[];
     priority: number;
+    /**
+     * Pool-level routing mode:
+     * - round-robin: force round-robin selection inside this pool (ignores global loadBalancing strategy)
+     * - priority: always pick highest-priority key first, only fallback when unavailable
+     */
+    mode?: RoutePoolMode;
     backup?: boolean;
     /**
      * Optional force flag for this route pool.
@@ -297,6 +304,19 @@ export interface RoutingDiagnostics {
     poolId?: string;
     confidence: number;
 }
+export interface StopMessageStateSnapshot {
+    stopMessageText: string;
+    stopMessageMaxRepeats: number;
+    /**
+     * stopMessage 来源：
+     * - 'explicit'：来自用户显式指令
+     * - 'auto'：系统基于空响应/错误自动推导
+     */
+    stopMessageSource?: string;
+    stopMessageUsed?: number;
+    stopMessageUpdatedAt?: number;
+    stopMessageLastUsedAt?: number;
+}
 export interface RoutingStatusSnapshot {
     routes: Record<string, {
         providers: string[];
@@ -373,3 +393,12 @@ export interface VirtualRouterHealthStore {
      */
     recordProviderError?(event: ProviderErrorEvent): void;
 }
+export interface ProviderQuotaViewEntry {
+    providerKey: string;
+    inPool: boolean;
+    reason?: string;
+    priorityTier?: number;
+    cooldownUntil?: number | null;
+    blacklistUntil?: number | null;
+}
+export type ProviderQuotaView = (providerKey: string) => ProviderQuotaViewEntry | null;