@jsonstudio/rcc 0.90.876 → 0.90.1270

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/engine/cooldown-manager.js

@@ -3,6 +3,53 @@
  *
  * Manages provider cooldown TTLs and health snapshot persistence.
  */
+const NON_BLOCKING_WARN_THROTTLE_MS = 60_000;
+const nonBlockingWarnByStage = new Map();
+function formatUnknownError(error) {
+    if (error instanceof Error) {
+        return error.stack || `${error.name}: ${error.message}`;
+    }
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error);
+    }
+}
+function shouldLogNonBlockingStage(stage) {
+    const now = Date.now();
+    const lastAt = nonBlockingWarnByStage.get(stage) ?? 0;
+    if (now - lastAt < NON_BLOCKING_WARN_THROTTLE_MS) {
+        return false;
+    }
+    nonBlockingWarnByStage.set(stage, now);
+    return true;
+}
+function resolveHealthStoreLogKey(store) {
+    const candidates = [
+        store?.filepath,
+        store?.filePath,
+        store?.path
+    ];
+    for (const candidate of candidates) {
+        if (typeof candidate === 'string' && candidate.trim()) {
+            return candidate.trim();
+        }
+    }
+    return 'virtual-router-health-store';
+}
+function logCooldownManagerNonBlockingError(stage, operation, error, details) {
+    if (!shouldLogNonBlockingStage(stage)) {
+        return;
+    }
+    try {
+        const suffix = details && Object.keys(details).length > 0 ? ` details=${JSON.stringify(details)}` : '';
+        console.warn(`[cooldown-manager] stage=${stage} operation=${operation} failed (non-blocking): ${formatUnknownError(error)}${suffix}`);
+    }
+    catch {
+        void 0;
+    }
+}
 export class CooldownManager {
     providerCooldowns = new Map();
     healthStore;
@@ -73,7 +120,10 @@ export class CooldownManager {
         try {
             snapshot = this.healthStore.loadInitialSnapshot();
         }
-        catch {
+        catch (error) {
+            logCooldownManagerNonBlockingError('state_restore', 'load_initial_snapshot', error, {
+                key: resolveHealthStoreLogKey(this.healthStore)
+            });
             snapshot = null;
         }
         if (!snapshot)
@@ -105,8 +155,10 @@ export class CooldownManager {
             const snapshot = this.buildHealthSnapshot();
             this.healthStore.persistSnapshot(snapshot);
         }
-        catch {
-            // persistence failure does not affect routing
+        catch (error) {
+            logCooldownManagerNonBlockingError('state_persist', 'persist_snapshot', error, {
+                key: resolveHealthStoreLogKey(this.healthStore)
+            });
         }
     }
     clearAllCooldowns() {

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/engine/health/index.js

@@ -1,6 +1,35 @@
 const SERIES_COOLDOWN_DETAIL_KEY = 'virtualRouterSeriesCooldown';
 const QUOTA_RECOVERY_DETAIL_KEY = 'virtualRouterQuotaRecovery';
 const QUOTA_DEPLETED_DETAIL_KEY = 'virtualRouterQuotaDepleted';
+function formatUnknownError(error) {
+    if (error instanceof Error) {
+        return error.stack || `${error.name}: ${error.message}`;
+    }
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error);
+    }
+}
+function logHealthNonBlockingError(stage, error, debug, details) {
+    const payload = details && Object.keys(details).length > 0 ? details : undefined;
+    try {
+        if (typeof debug?.log === 'function') {
+            debug.log('[virtual-router] health non-blocking failure', {
+                stage,
+                error: formatUnknownError(error),
+                ...(payload ? { details: payload } : {})
+            });
+            return;
+        }
+        const suffix = payload ? ` details=${JSON.stringify(payload)}` : '';
+        console.warn(`[virtual-router] ${stage} failed (non-blocking): ${formatUnknownError(error)}${suffix}`);
+    }
+    catch {
+        // Never throw from non-blocking logging.
+    }
+}
 function parseDurationToMs(value) {
     if (!value || typeof value !== 'string') {
         return null;
@@ -346,8 +375,11 @@ export function applyAntigravityRiskPolicyImpl(event, providerRegistry, healthMa
                 healthManager.tripProvider(key, 'auth_verify', ANTIGRAVITY_AUTH_VERIFY_BAN_MS);
                 markProviderCooldown(key, ANTIGRAVITY_AUTH_VERIFY_BAN_MS);
             }
-            catch {
-                // ignore lookup failures
+            catch (tripError) {
+                logHealthNonBlockingError('applyAntigravityRiskPolicy.authVerify.tripProvider', tripError, debug, {
+                    providerKey: key,
+                    runtimeKey
+                });
             }
         }
         debug?.log?.('[virtual-router] antigravity auth verify blacklist', {
@@ -380,8 +412,11 @@ export function applyAntigravityRiskPolicyImpl(event, providerRegistry, healthMa
                 markProviderCooldown(key, ANTIGRAVITY_THOUGHT_SIGNATURE_MISSING_COOLDOWN_MS);
                 affected.push(key);
             }
-            catch {
-                // ignore lookup failures
+            catch (tripError) {
+                logHealthNonBlockingError('applyAntigravityRiskPolicy.signatureMissing.tripProvider', tripError, debug, {
+                    providerKey: key,
+                    runtimeKey
+                });
             }
         }
         if (affected.length) {
@@ -430,8 +465,11 @@ export function applyAntigravityRiskPolicyImpl(event, providerRegistry, healthMa
                 healthManager.tripProvider(key, 'risk_cooldown', ANTIGRAVITY_RISK_COOLDOWN_MS);
                 markProviderCooldown(key, ANTIGRAVITY_RISK_COOLDOWN_MS);
             }
-            catch {
-                // ignore lookup failures
+            catch (tripError) {
+                logHealthNonBlockingError('applyAntigravityRiskPolicy.riskCooldown.tripProvider', tripError, debug, {
+                    providerKey: key,
+                    runtimeKey
+                });
             }
         }
         debug?.log?.('[virtual-router] antigravity risk cooldown', {
@@ -449,8 +487,11 @@ export function applyAntigravityRiskPolicyImpl(event, providerRegistry, healthMa
                 healthManager.tripProvider(key, 'risk_blacklist', ttl);
                 markProviderCooldown(key, ttl);
             }
-            catch {
-                // ignore lookup failures
+            catch (tripError) {
+                logHealthNonBlockingError('applyAntigravityRiskPolicy.riskBlacklist.tripProvider', tripError, debug, {
+                    providerKey: key,
+                    runtimeKey
+                });
             }
         }
         debug?.log?.('[virtual-router] antigravity risk blacklist', {
@@ -518,7 +559,7 @@ export function mapProviderErrorImpl(event, healthConfig) {
         ? runtime.providerId
         : undefined;
     const providerTag = (providerFamily || providerId || '').toLowerCase();
-    const isOAuthAuth406 = statusCode === 406 && (providerTag === 'iflow' || providerTag === 'qwen');
+    const isOAuthAuth406 = statusCode === 406 && (providerTag === 'qwen');
     let fatal = !recoverable;
     let reason = deriveReason(code, stage, statusCode);
     let cooldownOverrideMs;
@@ -600,8 +641,11 @@ export function applySeriesCooldownImpl(event, providerRegistry, healthManager,
             markProviderCooldown(providerKey, seriesDetail.cooldownMs);
             affected.push(providerKey);
         }
-        catch {
-            // ignore lookup failures; invalid keys may show up if config drifted
+        catch (tripError) {
+            logHealthNonBlockingError('applySeriesCooldown.tripProvider', tripError, debug, {
+                providerKey,
+                series: seriesDetail.series
+            });
         }
     }
     if (affected.length) {
@@ -654,8 +698,11 @@ export function applyQuotaRecoveryImpl(event, healthManager, clearProviderCooldo
         resetRateLimitBackoffForProvider(providerKey);
         clearProviderCooldown(providerKey);
     }
-    catch {
-        // 恢复失败不得影响主路由流程
+    catch (recoveryError) {
+        logHealthNonBlockingError('applyQuotaRecovery', recoveryError, debug, {
+            providerKey,
+            reason: detail.reason
+        });
     }
     return true;
 }
@@ -699,8 +746,12 @@ export function applyQuotaDepletedImpl(event, healthManager, markProviderCooldow
             reason: detail.reason
         });
     }
-    catch {
-        // ignore failures
+    catch (depletedError) {
+        logHealthNonBlockingError('applyQuotaDepleted', depletedError, debug, {
+            providerKey: detail.providerKey,
+            cooldownMs: ttl,
+            reason: detail.reason
+        });
     }
     return true;
 }

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/engine/routing-pools/index.js

@@ -220,9 +220,6 @@ function requestRequiresSearchRoute(requestedRoute, classification, features) {
     if (candidates.some((route) => route === 'web_search' || route === 'search')) {
         return true;
     }
-    if (features.hasWebSearchToolDeclared === true) {
-        return true;
-    }
     return features.metadata?.serverToolRequired === true;
 }
 function routeTargetsIncludeProvider(routing, routeName, providerKey) {
@@ -343,8 +340,11 @@ function selectFromCandidates(routes, metadata, classification, features, state,
         ? Math.max(0, features.estimatedTokens)
         : 0;
     const webSearchRouteRequested = isWebSearchRouteRequested(classification.routeName, classification);
-    const defaultWebSearchPools = filterPoolsByCapability(deps.routing[DEFAULT_ROUTE], 'web_search', deps.providerRegistry);
+    const multimodalRouteRequested = isMultimodalRouteRequested(classification.routeName, classification, features);
+    const defaultWebSearchPools = filterPoolsByCapability(deps.routing[DEFAULT_ROUTE], ['web_search'], deps.providerRegistry);
+    const defaultMultimodalPools = filterPoolsByCapability(deps.routing[DEFAULT_ROUTE], ['multimodal', 'vision'], deps.providerRegistry);
     const hasDefaultWebSearchFallback = routeHasTargets(defaultWebSearchPools);
+    const hasDefaultMultimodalFallback = routeHasTargets(defaultMultimodalPools);
     while (routeQueue.length) {
         const routeName = routeQueue.shift();
         if (visitedRoutes.has(routeName)) {
@@ -352,9 +352,17 @@ function selectFromCandidates(routes, metadata, classification, features, state,
         }
         let routePools = webSearchRouteRequested && routeName === DEFAULT_ROUTE && hasDefaultWebSearchFallback
             ? defaultWebSearchPools
-            : deps.routing[routeName];
+            : multimodalRouteRequested && routeName === DEFAULT_ROUTE && hasDefaultMultimodalFallback
+                ? defaultMultimodalPools
+                : deps.routing[routeName];
         if (webSearchRouteRequested && (routeName === 'web_search' || routeName === DEFAULT_ROUTE)) {
-            const capabilityFiltered = filterPoolsByCapability(routePools, 'web_search', deps.providerRegistry);
+            const capabilityFiltered = filterPoolsByCapability(routePools, ['web_search'], deps.providerRegistry);
+            if (routeHasTargets(capabilityFiltered)) {
+                routePools = capabilityFiltered;
+            }
+        }
+        if (multimodalRouteRequested && (routeName === 'multimodal' || routeName === 'vision' || routeName === DEFAULT_ROUTE)) {
+            const capabilityFiltered = filterPoolsByCapability(routePools, ['multimodal', 'vision'], deps.providerRegistry);
             if (routeHasTargets(capabilityFiltered)) {
                 routePools = capabilityFiltered;
             }
@@ -401,7 +409,11 @@ function selectFromCandidates(routes, metadata, classification, features, state,
     }
     throw new VirtualRouterError(`All providers unavailable for route ${requestedRoute}`, VirtualRouterErrorCode.PROVIDER_NOT_AVAILABLE, details);
 }
-function filterPoolsByCapability(pools, capability, providerRegistry) {
+function filterPoolsByCapability(pools, capabilities, providerRegistry) {
+    const expected = Array.from(new Set(capabilities.filter(Boolean)));
+    if (expected.length === 0) {
+        return [];
+    }
     if (!Array.isArray(pools)) {
         return [];
     }
@@ -410,7 +422,13 @@ function filterPoolsByCapability(pools, capability, providerRegistry) {
         if (!Array.isArray(pool.targets) || pool.targets.length === 0) {
             continue;
         }
-        const targets = pool.targets.filter((providerKey) => providerRegistry.hasCapability(providerKey, capability));
+        const targets = pool.targets.filter((providerKey) => expected.some((capability) => {
+            if (capability === 'vision') {
+                return (providerRegistry.hasCapability(providerKey, 'multimodal') ||
+                    providerRegistry.hasCapability(providerKey, capability));
+            }
+            return providerRegistry.hasCapability(providerKey, capability);
+        }));
         if (!targets.length) {
             continue;
         }
@@ -425,3 +443,21 @@ function isWebSearchRouteRequested(requestedRoute, classification) {
     return (normalizeRouteAlias(requestedRoute || DEFAULT_ROUTE) === 'web_search' ||
         normalizeRouteAlias(classification.routeName || DEFAULT_ROUTE) === 'web_search');
 }
+function isMultimodalRouteRequested(requestedRoute, classification, features) {
+    if (features.hasImageAttachment !== true) {
+        return false;
+    }
+    const normalizedRequestedRoute = normalizeRouteAlias(requestedRoute || DEFAULT_ROUTE);
+    const normalizedClassifiedRoute = normalizeRouteAlias(classification.routeName || DEFAULT_ROUTE);
+    if (normalizedRequestedRoute === 'multimodal' || normalizedRequestedRoute === 'vision') {
+        return true;
+    }
+    if (normalizedClassifiedRoute === 'multimodal' || normalizedClassifiedRoute === 'vision') {
+        return true;
+    }
+    const candidates = Array.isArray(classification.candidates) ? classification.candidates : [];
+    if (candidates.some((route) => route === 'multimodal' || route === 'vision')) {
+        return true;
+    }
+    return true;
+}

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/engine/routing-state/keys.d.ts

@@ -1,3 +1,10 @@
 import type { RouterMetadataInput } from '../../types.js';
+export declare function resolveConversationScopeValue(conversationId: unknown): string | undefined;
+export declare function resolveContinuationRequestChainKey(continuation: unknown): string | undefined;
+export declare function resolveLegacyResponsesRequestChainKey(responsesResume: unknown): string | undefined;
+export declare function resolveSessionScopeValue(scope: {
+    sessionId?: unknown;
+    conversationId?: unknown;
+}): string | undefined;
 export declare function resolveSessionScope(metadata: RouterMetadataInput): string | undefined;
 export declare function resolveStickyKey(metadata: RouterMetadataInput): string;

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/engine/routing-state/keys.js

@@ -1,30 +1,74 @@
-export function resolveSessionScope(metadata) {
-    const sessionId = typeof metadata.sessionId === 'string' ? metadata.sessionId.trim() : '';
+function asRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return undefined;
+    }
+    return value;
+}
+function readText(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed || undefined;
+}
+export function resolveConversationScopeValue(conversationId) {
+    const normalized = readText(conversationId);
+    return normalized ? `conversation:${normalized}` : undefined;
+}
+export function resolveContinuationRequestChainKey(continuation) {
+    const row = asRecord(continuation);
+    if (!row) {
+        return undefined;
+    }
+    const stickyScope = readText(row.stickyScope);
+    if (stickyScope !== 'request_chain') {
+        return undefined;
+    }
+    const resumeFrom = asRecord(row.resumeFrom);
+    return readText(row.chainId) ?? readText(resumeFrom?.requestId);
+}
+export function resolveLegacyResponsesRequestChainKey(responsesResume) {
+    const resume = asRecord(responsesResume);
+    return readText(resume?.previousRequestId);
+}
+export function resolveSessionScopeValue(scope) {
+    const sessionId = readText(scope.sessionId);
     if (sessionId) {
         return `session:${sessionId}`;
     }
-    const conversationId = typeof metadata.conversationId === 'string' ? metadata.conversationId.trim() : '';
-    if (conversationId) {
-        return `conversation:${conversationId}`;
-    }
-    return undefined;
+    return resolveConversationScopeValue(scope.conversationId);
+}
+function readConversationScope(metadata) {
+    return resolveConversationScopeValue(metadata.conversationId);
+}
+function readStickyScope(continuation) {
+    return readText(asRecord(continuation)?.stickyScope);
+}
+export function resolveSessionScope(metadata) {
+    return resolveSessionScopeValue(metadata);
 }
 export function resolveStickyKey(metadata) {
-    const providerProtocol = metadata.providerProtocol;
-    // For Responses protocol, auto-sticky is request-chain scoped:
-    // - resume/submit: stickyKey = previousRequestId (points to chain root)
-    // - normal call: stickyKey = requestId
-    if (providerProtocol === 'openai-responses') {
-        const resume = metadata.responsesResume;
-        if (resume && typeof resume.previousRequestId === 'string' && resume.previousRequestId.trim()) {
-            return resume.previousRequestId.trim();
-        }
+    const stickyScope = readStickyScope(metadata.continuation);
+    const requestChainKey = resolveContinuationRequestChainKey(metadata.continuation);
+    if (requestChainKey) {
+        return requestChainKey;
+    }
+    if (stickyScope === 'session') {
+        return resolveSessionScope(metadata) ?? metadata.requestId;
+    }
+    if (stickyScope === 'conversation') {
+        return readConversationScope(metadata) ?? resolveSessionScope(metadata) ?? metadata.requestId;
+    }
+    if (stickyScope === 'request') {
         return metadata.requestId;
     }
-    // Other protocols: session/conversation scoped when available.
-    const sessionScope = resolveSessionScope(metadata);
-    if (sessionScope) {
-        return sessionScope;
+    // Migration fallback only: prefer unified continuation when present, then legacy responses resume.
+    if (metadata.providerProtocol === 'openai-responses') {
+        const previousRequestId = resolveLegacyResponsesRequestChainKey(metadata.responsesResume);
+        if (previousRequestId) {
+            return previousRequestId;
+        }
+        return metadata.requestId;
     }
-    return metadata.requestId;
+    return resolveSessionScope(metadata) ?? metadata.requestId;
 }

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/engine/routing-state/store.js

@@ -1,5 +1,5 @@
 import { mergeStopMessageFromPersisted } from '../../stop-message-state-sync.js';
-import { providerErrorCenter } from '../../error-center.js';
+import { reportProviderErrorToRouterPolicy } from '../../provider-runtime-ingress.js';
 function formatError(error) {
     if (error instanceof Error) {
         return error.message;
@@ -8,7 +8,7 @@ function formatError(error) {
 }
 function emitRoutingStateRefreshError(key, error) {
     const errorMessage = formatError(error);
-    providerErrorCenter.emit({
+    reportProviderErrorToRouterPolicy({
         code: 'STICKY_STATE_REFRESH_FAILED',
         message: 'failed to refresh in-memory routing state from persisted sticky store',
         stage: 'sticky_session.refresh',
@@ -92,6 +92,10 @@ export function getRoutingInstructionState(stickyKey, routingInstructionState, r
             existing.stopMessageAiMode = merged.stopMessageAiMode;
             existing.stopMessageAiSeedPrompt = merged.stopMessageAiSeedPrompt;
             existing.stopMessageAiHistory = merged.stopMessageAiHistory;
+            existing.reasoningStopMode = merged.reasoningStopMode;
+            existing.reasoningStopArmed = merged.reasoningStopArmed;
+            existing.reasoningStopSummary = merged.reasoningStopSummary;
+            existing.reasoningStopUpdatedAt = merged.reasoningStopUpdatedAt;
             if (persisted) {
                 existing.preCommandSource = persisted.preCommandSource;
                 existing.preCommandScriptPath = persisted.preCommandScriptPath;
@@ -127,6 +131,10 @@ export function getRoutingInstructionState(stickyKey, routingInstructionState, r
             stopMessageAiMode: undefined,
             stopMessageAiSeedPrompt: undefined,
             stopMessageAiHistory: undefined,
+            reasoningStopMode: undefined,
+            reasoningStopArmed: undefined,
+            reasoningStopSummary: undefined,
+            reasoningStopUpdatedAt: undefined,
             preCommandSource: undefined,
             preCommandScriptPath: undefined,
             preCommandUpdatedAt: undefined
@@ -151,6 +159,10 @@ function isRoutingStateEmpty(state) {
         (typeof state.stopMessageUsed !== 'number' || !Number.isFinite(state.stopMessageUsed)) &&
         (typeof state.stopMessageStageMode !== 'string' || !state.stopMessageStageMode.trim()) &&
         (typeof state.stopMessageAiMode !== 'string' || !state.stopMessageAiMode.trim());
+    const noReasoningStop = (typeof state.reasoningStopMode !== 'string' || !state.reasoningStopMode.trim()) &&
+        state.reasoningStopArmed !== true &&
+        (typeof state.reasoningStopSummary !== 'string' || !state.reasoningStopSummary.trim()) &&
+        (typeof state.reasoningStopUpdatedAt !== 'number' || !Number.isFinite(state.reasoningStopUpdatedAt));
     const noPreCommand = (!state.preCommandScriptPath || !state.preCommandScriptPath.trim()) &&
         (typeof state.preCommandUpdatedAt !== 'number' || !Number.isFinite(state.preCommandUpdatedAt));
     return (noForced &&
@@ -161,6 +173,7 @@ function isRoutingStateEmpty(state) {
         noDisabledKeys &&
         noDisabledModels &&
         noStopMessage &&
+        noReasoningStop &&
         noPreCommand);
 }
 export function persistRoutingInstructionState(key, state, routingStateStore) {
@@ -178,6 +191,10 @@ export function persistRoutingInstructionState(key, state, routingStateStore) {
             (typeof state.stopMessageUsed === 'number' && Number.isFinite(state.stopMessageUsed)) ||
             Boolean(state.stopMessageStageMode && state.stopMessageStageMode.trim()) ||
             Boolean(state.stopMessageAiMode && state.stopMessageAiMode.trim()) ||
+            Boolean(state.reasoningStopMode && state.reasoningStopMode.trim()) ||
+            state.reasoningStopArmed === true ||
+            Boolean(state.reasoningStopSummary && state.reasoningStopSummary.trim()) ||
+            (typeof state.reasoningStopUpdatedAt === 'number' && Number.isFinite(state.reasoningStopUpdatedAt)) ||
             Boolean(state.preCommandScriptPath && state.preCommandScriptPath.trim()) ||
             (typeof state.preCommandUpdatedAt === 'number' && Number.isFinite(state.preCommandUpdatedAt)));
     if (isRoutingStateEmpty(state)) {

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/engine/sticky-session-manager.d.ts

@@ -11,7 +11,11 @@ export declare class StickySessionManager {
     private aliasQueueStore;
     private antigravityAliasLeaseStore;
     private antigravitySessionAliasStore;
+    private aliasQueueTouchedAt;
+    private sessionAliasTouchedAt;
     private antigravityAliasReuseCooldownMs;
+    private readonly stickySessionTtlMs;
+    private readonly stickySessionMaxEntries;
     constructor(aliasReuseCooldownMs?: number);
     getAliasQueue(alias: string): string[] | undefined;
     setAliasQueue(alias: string, queue: string[]): void;
@@ -26,4 +30,9 @@ export declare class StickySessionManager {
         aliasLeaseStore: Map<string, AliasLease>;
         sessionAliasStore: Map<string, string>;
     };
+    private prune;
+    private enforceAliasQueueBudget;
+    private enforceAliasLeaseBudget;
+    private enforceSessionAliasBudget;
+    private evictTouchedMapBudget;
 }