@jsonstudio/llms 0.6.567 → 0.6.586

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

@@ -13,18 +13,21 @@ export class RoutingClassifier {
         const lastToolCategory = features.lastAssistantToolCategory;
         const reachedLongContext = features.estimatedTokens >= (this.config.longContextThresholdTokens ?? DEFAULT_LONG_CONTEXT_THRESHOLD);
         const latestMessageFromUser = features.latestMessageFromUser === true;
-        const codingContinuation = lastToolCategory === 'write';
         const thinkingContinuation = lastToolCategory === 'read';
+        const thinkingFromUser = latestMessageFromUser;
+        const thinkingFromRead = !thinkingFromUser && thinkingContinuation;
+        const codingContinuation = lastToolCategory === 'write';
         const searchContinuation = lastToolCategory === 'search';
         const toolsContinuation = lastToolCategory === 'other';
+        const hasToolActivity = features.hasTools || features.hasToolCallResponses;
         const evaluationMap = {
             vision: {
                 triggered: features.hasImageAttachment,
                 reason: 'vision:image-detected'
             },
             thinking: {
-                triggered: latestMessageFromUser,
-                reason: 'thinking:user-input'
+                triggered: thinkingFromUser || thinkingFromRead,
+                reason: thinkingFromUser ? 'thinking:user-input' : 'thinking:last-tool-read'
             },
             longcontext: {
                 triggered: reachedLongContext,
@@ -34,16 +37,22 @@ export class RoutingClassifier {
                 triggered: codingContinuation,
                 reason: 'coding:last-tool-write'
             },
-            thinking_continuation: {
-                triggered: thinkingContinuation,
-                reason: 'thinking:last-tool-read'
+            web_search: {
+                // web_search 路由不再基于上一轮工具分类或本轮是否声明 web_search 工具自动触发，
+                // 仅保留为显式路由指令/未来扩展的占位，默认不命中。
+                triggered: false,
+                reason: 'web_search:disabled'
             },
             search: {
+                // search 路由：仅在上一轮 assistant 使用 search 类工具时继续命中，
+                // 不因本轮是否声明 web_search 工具而改变路由。
                 triggered: searchContinuation,
                 reason: 'search:last-tool-search'
             },
             tools: {
-                triggered: toolsContinuation || features.hasTools || features.hasToolCallResponses,
+                // tools 路由：通用工具分支，包括首次声明的 web/search 工具。
+                // 若上一轮已明确归类为 search，则优先命中 search 路由，tools 仅作为兜底。
+                triggered: toolsContinuation || (!searchContinuation && hasToolActivity),
                 reason: toolsContinuation ? 'tools:last-tool-other' : 'tools:tool-request-detected'
             },
             background: {

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

@@ -4,8 +4,19 @@ import type { ProviderErrorEvent, ProviderFailureEvent, ProviderHealthConfig } f
 type DebugLike = {
     log?: (...args: unknown[]) => void;
 } | Console | undefined;
+export declare function resetRateLimitBackoffForProvider(providerKey: string): void;
 export declare function handleProviderFailureImpl(event: ProviderFailureEvent, healthManager: ProviderHealthManager, healthConfig: Required<ProviderHealthConfig>, markProviderCooldown: (providerKey: string, cooldownMs: number | undefined) => void): void;
 export declare function mapProviderErrorImpl(event: ProviderErrorEvent, healthConfig: Required<ProviderHealthConfig>): ProviderFailureEvent | null;
 export declare function applySeriesCooldownImpl(event: ProviderErrorEvent, providerRegistry: ProviderRegistry, healthManager: ProviderHealthManager, markProviderCooldown: (providerKey: string, cooldownMs: number | undefined) => void, debug?: DebugLike): void;
+/**
+ * 处理来自 Host 侧的配额恢复事件：
+ * - 清除指定 providerKey 在健康管理器中的熔断/冷却状态；
+ * - 清理对应的速率退避计数；
+ * - 调用调用方提供的 clearProviderCooldown 回调移除显式 cooldown TTL。
+ *
+ * 返回值表示是否已处理（true=已处理且后续应跳过常规错误映射逻辑）。
+ */
+export declare function applyQuotaRecoveryImpl(event: ProviderErrorEvent, healthManager: ProviderHealthManager, clearProviderCooldown: (providerKey: string) => void, debug?: DebugLike): boolean;
+export declare function applyQuotaDepletedImpl(event: ProviderErrorEvent, healthManager: ProviderHealthManager, markProviderCooldown: (providerKey: string, cooldownMs: number | undefined) => void, debug?: DebugLike): boolean;
 export declare function deriveReason(code: string, stage: string, statusCode?: number): string;
 export {};

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

@@ -1,4 +1,105 @@
 const SERIES_COOLDOWN_DETAIL_KEY = 'virtualRouterSeriesCooldown';
+const QUOTA_RECOVERY_DETAIL_KEY = 'virtualRouterQuotaRecovery';
+const QUOTA_DEPLETED_DETAIL_KEY = 'virtualRouterQuotaDepleted';
+function parseDurationToMs(value) {
+    if (!value || typeof value !== 'string') {
+        return null;
+    }
+    const pattern = /(\d+(?:\.\d+)?)(ms|s|m|h)/gi;
+    let totalMs = 0;
+    let matched = false;
+    let match;
+    while ((match = pattern.exec(value)) !== null) {
+        matched = true;
+        const amount = Number.parseFloat(match[1]);
+        if (!Number.isFinite(amount)) {
+            continue;
+        }
+        const unit = match[2].toLowerCase();
+        if (unit === 'ms') {
+            totalMs += amount;
+        }
+        else if (unit === 'h') {
+            totalMs += amount * 3_600_000;
+        }
+        else if (unit === 'm') {
+            totalMs += amount * 60_000;
+        }
+        else if (unit === 's') {
+            totalMs += amount * 1_000;
+        }
+    }
+    if (!matched) {
+        const seconds = Number.parseFloat(value);
+        if (Number.isFinite(seconds)) {
+            totalMs = seconds * 1_000;
+            matched = true;
+        }
+    }
+    if (!matched || totalMs <= 0) {
+        return null;
+    }
+    return Math.round(totalMs);
+}
+function readEnvSchedule(name, fallback) {
+    const raw = (process.env[name] || '').trim();
+    if (!raw) {
+        return fallback;
+    }
+    const parts = raw.split(',').map((token) => token.trim()).filter(Boolean);
+    const parsed = [];
+    for (const part of parts) {
+        const ms = parseDurationToMs(part);
+        if (ms && ms > 0) {
+            parsed.push(ms);
+        }
+    }
+    return parsed.length ? parsed : fallback;
+}
+function readEnvDuration(name, fallbackMs) {
+    const raw = (process.env[name] || '').trim();
+    if (!raw) {
+        return fallbackMs;
+    }
+    const ms = parseDurationToMs(raw);
+    return ms && ms > 0 ? ms : fallbackMs;
+}
+/**
+ * 对没有 quotaResetDelay 的 429 错误，在 VirtualRouter 内部维护一个简单的阶梯退避策略：
+ * - 默认：第 1 次 5 分钟，第 2 次 1 小时，第 3 次 6 小时，第 4 次及以上 24 小时封顶；
+ * - 可通过环境变量 ROUTECODEX_RL_SCHEDULE / RCC_RL_SCHEDULE 调整（例如 "5m,1h,6h,24h"）。
+ *
+ * 这里的“次数”针对 providerKey 计数，并带有简单的时间窗口：若距离上次 429 超过 24 小时，则重置计数。
+ * 该状态仅用于路由决策，不反映在 healthConfig 上，使 Host 与 VirtualRouter 对 429 处理职责清晰分层。
+ */
+const NO_QUOTA_RATE_LIMIT_SCHEDULE_MS = readEnvSchedule('ROUTECODEX_RL_SCHEDULE', [
+    5 * 60_000,
+    60 * 60_000,
+    6 * 60 * 60_000,
+    24 * 60 * 60_000
+]);
+const rateLimitBackoffByProvider = new Map();
+const RATE_LIMIT_RESET_WINDOW_MS = readEnvDuration('ROUTECODEX_RL_RESET_WINDOW', 24 * 60 * 60_000);
+function computeRateLimitCooldownMsForProvider(providerKey, now) {
+    const prev = rateLimitBackoffByProvider.get(providerKey);
+    let nextCount = 1;
+    if (prev) {
+        const elapsed = now - prev.lastAt;
+        if (Number.isFinite(elapsed) && elapsed >= 0 && elapsed < RATE_LIMIT_RESET_WINDOW_MS) {
+            nextCount = prev.count + 1;
+        }
+    }
+    const idx = Math.min(nextCount - 1, NO_QUOTA_RATE_LIMIT_SCHEDULE_MS.length - 1);
+    const ttl = NO_QUOTA_RATE_LIMIT_SCHEDULE_MS[idx];
+    rateLimitBackoffByProvider.set(providerKey, { count: nextCount, lastAt: now });
+    return ttl;
+}
+export function resetRateLimitBackoffForProvider(providerKey) {
+    if (!providerKey) {
+        return;
+    }
+    rateLimitBackoffByProvider.delete(providerKey);
+}
 export function handleProviderFailureImpl(event, healthManager, healthConfig, markProviderCooldown) {
     if (!event || !event.providerKey) {
         return;
@@ -10,9 +111,17 @@ export function handleProviderFailureImpl(event, healthManager, healthConfig, ma
         healthManager.tripProvider(event.providerKey, event.reason, event.cooldownOverrideMs);
     }
     else if (event.reason === 'rate_limit' && event.statusCode === 429) {
-        healthManager.cooldownProvider(event.providerKey, event.reason, event.cooldownOverrideMs);
-        const ttl = event.cooldownOverrideMs ?? healthConfig.cooldownMs;
-        markProviderCooldown(event.providerKey, ttl);
+        // 对非致命的 429 错误：
+        // - 若 ProviderErrorEvent 已携带显式 cooldownOverrideMs（例如来自 quotaResetDelay），则直接使用；
+        // - 否则针对该 providerKey 启用阶梯退避策略（5min → 1h → 6h → 24h），
+        //   在冷却期内从路由池中移除该 alias，避免持续命中上游。
+        const providerKey = event.providerKey;
+        let ttl = event.cooldownOverrideMs;
+        if (!ttl || !Number.isFinite(ttl) || ttl <= 0) {
+            ttl = computeRateLimitCooldownMsForProvider(providerKey, Date.now());
+        }
+        healthManager.cooldownProvider(providerKey, event.reason, ttl);
+        markProviderCooldown(providerKey, ttl);
     }
     else {
         healthManager.recordFailure(event.providerKey, event.reason);
@@ -35,10 +144,20 @@ export function mapProviderErrorImpl(event, healthConfig) {
     const code = event.code?.toUpperCase() ?? 'ERR_UNKNOWN';
     const stage = event.stage?.toLowerCase() ?? 'unknown';
     const recoverable = event.recoverable === true;
+    const providerFamily = runtime.providerFamily &&
+        typeof runtime.providerFamily === 'string'
+        ? runtime.providerFamily
+        : undefined;
+    const providerId = runtime.providerId &&
+        typeof runtime.providerId === 'string'
+        ? runtime.providerId
+        : undefined;
+    const providerTag = (providerFamily || providerId || '').toLowerCase();
+    const isOAuthAuth406 = statusCode === 406 && (providerTag === 'iflow' || providerTag === 'qwen');
     let fatal = !recoverable;
     let reason = deriveReason(code, stage, statusCode);
     let cooldownOverrideMs;
-    if (statusCode === 401 || statusCode === 402 || statusCode === 403 || code.includes('AUTH')) {
+    if (statusCode === 401 || statusCode === 402 || statusCode === 403 || code.includes('AUTH') || isOAuthAuth406) {
         fatal = true;
         cooldownOverrideMs = Math.max(10 * 60_000, healthConfig.fatalCooldownMs ?? 10 * 60_000);
         reason = 'auth';
@@ -117,6 +236,100 @@ export function applySeriesCooldownImpl(event, providerRegistry, healthManager,
         });
     }
 }
+function extractQuotaRecoveryDetail(event) {
+    if (!event || !event.details || typeof event.details !== 'object') {
+        return null;
+    }
+    const raw = event.details[QUOTA_RECOVERY_DETAIL_KEY];
+    if (!raw || typeof raw !== 'object') {
+        return null;
+    }
+    const record = raw;
+    const providerKeyRaw = record.providerKey;
+    if (typeof providerKeyRaw !== 'string' || !providerKeyRaw.trim()) {
+        return null;
+    }
+    const reason = typeof record.reason === 'string' && record.reason.trim()
+        ? record.reason.trim()
+        : undefined;
+    return {
+        providerKey: providerKeyRaw.trim(),
+        reason
+    };
+}
+/**
+ * 处理来自 Host 侧的配额恢复事件：
+ * - 清除指定 providerKey 在健康管理器中的熔断/冷却状态；
+ * - 清理对应的速率退避计数；
+ * - 调用调用方提供的 clearProviderCooldown 回调移除显式 cooldown TTL。
+ *
+ * 返回值表示是否已处理（true=已处理且后续应跳过常规错误映射逻辑）。
+ */
+export function applyQuotaRecoveryImpl(event, healthManager, clearProviderCooldown, debug) {
+    const detail = extractQuotaRecoveryDetail(event);
+    if (!detail) {
+        return false;
+    }
+    const providerKey = detail.providerKey;
+    try {
+        healthManager.recordSuccess(providerKey);
+        resetRateLimitBackoffForProvider(providerKey);
+        clearProviderCooldown(providerKey);
+        debug?.log?.('[virtual-router] quota recovery', {
+            providerKey,
+            reason: detail.reason
+        });
+    }
+    catch {
+        // 恢复失败不得影响主路由流程
+    }
+    return true;
+}
+function extractQuotaDepletedDetail(event) {
+    if (!event || !event.details || typeof event.details !== 'object') {
+        return null;
+    }
+    const raw = event.details[QUOTA_DEPLETED_DETAIL_KEY];
+    if (!raw || typeof raw !== 'object') {
+        return null;
+    }
+    const record = raw;
+    const providerKeyRaw = record.providerKey;
+    if (typeof providerKeyRaw !== 'string' || !providerKeyRaw.trim()) {
+        return null;
+    }
+    const cooldownMs = typeof record.cooldownMs === 'number' && Number.isFinite(record.cooldownMs) && record.cooldownMs > 0
+        ? record.cooldownMs
+        : undefined;
+    const reason = typeof record.reason === 'string' && record.reason.trim()
+        ? record.reason.trim()
+        : undefined;
+    return {
+        providerKey: providerKeyRaw.trim(),
+        cooldownMs,
+        reason
+    };
+}
+export function applyQuotaDepletedImpl(event, healthManager, markProviderCooldown, debug) {
+    const detail = extractQuotaDepletedDetail(event);
+    if (!detail) {
+        return false;
+    }
+    const ttl = detail.cooldownMs;
+    try {
+        healthManager.cooldownProvider(detail.providerKey, 'rate_limit', ttl);
+        markProviderCooldown(detail.providerKey, ttl);
+        debug?.log?.('[virtual-router] quota depleted', {
+            providerKey: detail.providerKey,
+            cooldownMs: ttl,
+            reason: detail.reason
+        });
+    }
+    catch {
+        // ignore failures
+    }
+    return true;
+}
 function resolveSeriesCooldownTargets(detail, event, providerRegistry) {
     const candidates = new Set();
     const push = (key) => {

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

@@ -1,5 +1,6 @@
 import { type ClassificationResult, type RoutingFeatures, type RoutingInstructionMode, type VirtualRouterContextRoutingConfig } from './types.js';
 import { ProviderRegistry } from './provider-registry.js';
+import type { RoutingInstructionState } from './routing-instructions.js';
 type LoggingDeps = {
     providerRegistry: ProviderRegistry;
     contextRouting: VirtualRouterContextRoutingConfig | undefined;
@@ -15,5 +16,5 @@ export declare function describeTargetProvider(providerKey: string, fallbackMode
     resolvedModel?: string;
 };
 export declare function buildHitReason(routeUsed: string, providerKey: string, classification: ClassificationResult, features: RoutingFeatures, mode: RoutingInstructionMode | undefined, deps: LoggingDeps): string;
-export declare function formatVirtualRouterHit(routeName: string, poolId: string | undefined, providerKey: string, modelId?: string, hitReason?: string, stickyScope?: string): string;
+export declare function formatVirtualRouterHit(routeName: string, poolId: string | undefined, providerKey: string, modelId?: string, hitReason?: string, stickyScope?: string, routingState?: RoutingInstructionState): string;
 export {};

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

@@ -132,7 +132,7 @@ export function buildHitReason(routeUsed, providerKey, classification, features,
     }
     return base;
 }
-export function formatVirtualRouterHit(routeName, poolId, providerKey, modelId, hitReason, stickyScope) {
+export function formatVirtualRouterHit(routeName, poolId, providerKey, modelId, hitReason, stickyScope, routingState) {
     try {
         const now = new Date();
         const hours = String(now.getHours()).padStart(2, '0');
@@ -144,6 +144,7 @@ export function formatVirtualRouterHit(routeName, poolId, providerKey, modelId,
         const timeColor = '\x1b[90m';
         const stickyColor = '\x1b[33m';
         const routeColor = resolveRouteColor(routeName);
+        const stopColor = '\x1b[38;5;214m';
         const prefix = `${prefixColor}[virtual-router-hit]${reset}`;
         const timeLabel = `${timeColor}${timestamp}${reset}`;
         const { providerLabel, resolvedModel } = describeTargetProvider(providerKey, modelId);
@@ -152,7 +153,29 @@ export function formatVirtualRouterHit(routeName, poolId, providerKey, modelId,
         const stickyText = formatStickyScope(stickyScope);
         const stickyLabel = stickyText ? ` ${stickyColor}[sticky:${stickyText}]${reset}` : '';
         const reasonLabel = hitReason ? ` reason=${hitReason}` : '';
-        return `${prefix} ${timeLabel} ${routeColor}${targetLabel}${stickyLabel}${reasonLabel}${reset}`;
+        let stopLabel = '';
+        if (routingState?.stopMessageText && typeof routingState.stopMessageMaxRepeats === 'number') {
+            const text = routingState.stopMessageText;
+            const safeText = text.length > 24 ? `${text.slice(0, 21)}…` : text;
+            const used = typeof routingState.stopMessageUsed === 'number' && Number.isFinite(routingState.stopMessageUsed)
+                ? routingState.stopMessageUsed
+                : 0;
+            const updatedAt = typeof routingState.stopMessageUpdatedAt === 'number' && Number.isFinite(routingState.stopMessageUpdatedAt)
+                ? routingState.stopMessageUpdatedAt
+                : undefined;
+            const lastUsedAt = typeof routingState.stopMessageLastUsedAt === 'number' && Number.isFinite(routingState.stopMessageLastUsedAt)
+                ? routingState.stopMessageLastUsedAt
+                : undefined;
+            const parts = [`"${safeText}"`, `${used}/${Math.floor(routingState.stopMessageMaxRepeats)}`];
+            if (updatedAt) {
+                parts.push(`set=${new Date(updatedAt).toLocaleString(undefined, { hour12: false })}`);
+            }
+            if (lastUsedAt) {
+                parts.push(`last=${new Date(lastUsedAt).toLocaleString(undefined, { hour12: false })}`);
+            }
+            stopLabel = ` ${stopColor}[stopMessage:${parts.join(' ')}]${reset}`;
+        }
+        return `${prefix} ${timeLabel} ${routeColor}${targetLabel}${stickyLabel}${reasonLabel}${stopLabel}${reset}`;
     }
     catch {
         const now = new Date();
@@ -160,6 +183,15 @@ export function formatVirtualRouterHit(routeName, poolId, providerKey, modelId,
         const routeLabel = poolId ? `${routeName}/${poolId}` : routeName;
         const stickyText = formatStickyScope(stickyScope);
         const stickyLabel = stickyText ? ` [sticky:${stickyText}]` : '';
-        return `[virtual-router-hit] ${timestamp} ${routeLabel} -> ${providerKey}${modelId ? '.' + modelId : ''}${stickyLabel}${hitReason ? ` reason=${hitReason}` : ''}`;
+        let stopLabel = '';
+        if (routingState?.stopMessageText && typeof routingState.stopMessageMaxRepeats === 'number') {
+            const text = routingState.stopMessageText;
+            const safeText = text.length > 24 ? `${text.slice(0, 21)}…` : text;
+            const used = typeof routingState.stopMessageUsed === 'number' && Number.isFinite(routingState.stopMessageUsed)
+                ? routingState.stopMessageUsed
+                : 0;
+            stopLabel = ` [stopMessage:"${safeText}" ${used}/${Math.floor(routingState.stopMessageMaxRepeats)}]`;
+        }
+        return `[virtual-router-hit] ${timestamp} ${routeLabel} -> ${providerKey}${modelId ? '.' + modelId : ''}${stickyLabel}${hitReason ? ` reason=${hitReason}` : ''}${stopLabel}`;
     }
 }

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

@@ -1,5 +1,10 @@
-import { type RoutingDecision, type RoutingDiagnostics, type RouterMetadataInput, type VirtualRouterConfig, type TargetMetadata, type ProviderFailureEvent, type ProviderErrorEvent } from './types.js';
+import { type RoutingDecision, type RoutingDiagnostics, 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';
+interface RoutingInstructionStateStore {
+    loadSync(key: string): RoutingInstructionState | null;
+    saveAsync(key: string, state: RoutingInstructionState | null): void;
+}
 export declare class VirtualRouterEngine {
     private routing;
     private readonly providerRegistry;
@@ -14,7 +19,13 @@ export declare class VirtualRouterEngine {
     private healthConfig;
     private readonly statsCenter;
     private webSearchForce;
+    private healthStore?;
+    private routingStateStore;
     private routingInstructionState;
+    constructor(deps?: {
+        healthStore?: VirtualRouterHealthStore;
+        routingStateStore?: RoutingInstructionStateStore;
+    });
     initialize(config: VirtualRouterConfig): void;
     route(request: StandardizedRequest | ProcessedRequest, metadata: RouterMetadataInput): {
         target: TargetMetadata;
@@ -82,5 +93,10 @@ export declare class VirtualRouterEngine {
     private isRoutingStateEmpty;
     private persistRoutingInstructionState;
     private markProviderCooldown;
+    private clearProviderCooldown;
     private isProviderCoolingDown;
+    private restoreHealthFromStore;
+    private buildHealthSnapshot;
+    private persistHealthSnapshot;
 }
+export {};