@jsonstudio/llms 0.6.147 → 0.6.198

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

@@ -1,4 +1,5 @@
-import { VirtualRouterError, VirtualRouterErrorCode } from './types.js';
+import { DEFAULT_MODEL_CONTEXT_TOKENS, VirtualRouterError, VirtualRouterErrorCode } from './types.js';
+import { scanOAuthTokenFiles } from './token-file-scanner.js';
 const DEFAULT_CLASSIFIER = {
     longContextThresholdTokens: 180000,
     thinkingKeywords: ['think step', 'analysis', 'reasoning', '仔细分析', '深度思考'],
@@ -8,6 +9,11 @@ const DEFAULT_CLASSIFIER = {
 };
 const DEFAULT_LOAD_BALANCING = { strategy: 'round-robin' };
 const DEFAULT_HEALTH = { failureThreshold: 3, cooldownMs: 30_000, fatalCooldownMs: 300_000 };
+const DEFAULT_CONTEXT_ROUTING = {
+    warnRatio: 0.9,
+    hardLimit: false,
+    fallbackRoute: 'longcontext'
+};
 /**
  * 将用户提供的 Virtual Router 配置（或包含 virtualrouter 字段的整体配置）
  * 规范化为 VirtualRouterConfig，供 HubPipeline / VirtualRouterEngine 直接使用。
@@ -31,12 +37,14 @@ export function bootstrapVirtualRouterConfig(input) {
     const classifier = normalizeClassifier(section.classifier);
     const loadBalancing = section.loadBalancing ?? DEFAULT_LOAD_BALANCING;
     const health = section.health ?? DEFAULT_HEALTH;
+    const contextRouting = section.contextRouting ?? DEFAULT_CONTEXT_ROUTING;
     const config = {
         routing,
         providers: providerProfiles,
         classifier,
         loadBalancing,
-        health
+        health,
+        contextRouting
     };
     return {
         config,
@@ -56,7 +64,8 @@ function extractVirtualRouterSection(input) {
     const classifier = (section.classifier ?? root.classifier);
     const loadBalancing = normalizeLoadBalancing(section.loadBalancing ?? root.loadBalancing);
     const health = normalizeHealth(section.health ?? root.health);
-    return { providers, routing, classifier, loadBalancing, health };
+    const contextRouting = normalizeContextRouting(section.contextRouting ?? root.contextRouting);
+    return { providers, routing, classifier, loadBalancing, health, contextRouting };
 }
 function buildProviderRuntimeEntries(providers) {
     const runtimeEntries = {};
@@ -100,7 +109,11 @@ function buildProviderRuntimeEntries(providers) {
                 outboundProfile: normalizedProvider.outboundProfile,
                 compatibilityProfile: normalizedProvider.compatibilityProfile,
                 processMode: normalizedProvider.processMode,
-                responsesConfig: normalizedProvider.responsesConfig
+                responsesConfig: normalizedProvider.responsesConfig,
+                streaming: normalizedProvider.streaming,
+                modelStreaming: normalizedProvider.modelStreaming,
+                modelContextTokens: normalizedProvider.modelContextTokens,
+                defaultContextTokens: normalizedProvider.defaultContextTokens
             };
         }
     }
@@ -146,6 +159,10 @@ function buildProviderProfiles(targetKeys, runtimeEntries) {
         if (!runtime) {
             throw new VirtualRouterError(`Routing target ${targetKey} references unknown runtime key ${runtimeKey}`, VirtualRouterErrorCode.CONFIG_ERROR);
         }
+        const streamingPref = runtime.modelStreaming?.[parsed.modelId] !== undefined
+            ? runtime.modelStreaming?.[parsed.modelId]
+            : runtime.streaming;
+        const contextTokens = resolveContextTokens(runtime, parsed.modelId);
         profiles[targetKey] = {
             providerKey: targetKey,
             providerType: runtime.providerType,
@@ -156,15 +173,30 @@ function buildProviderProfiles(targetKeys, runtimeEntries) {
             runtimeKey,
             modelId: parsed.modelId,
             processMode: runtime.processMode || 'chat',
-            responsesConfig: runtime.responsesConfig
+            responsesConfig: runtime.responsesConfig,
+            streaming: streamingPref,
+            maxContextTokens: contextTokens
         };
         targetRuntime[targetKey] = {
             ...runtime,
-            modelId: parsed.modelId
+            modelId: parsed.modelId,
+            streaming: streamingPref,
+            maxContextTokens: contextTokens
         };
     }
     return { profiles, targetRuntime };
 }
+function resolveContextTokens(runtime, modelId) {
+    const specific = runtime.modelContextTokens?.[modelId];
+    if (typeof specific === 'number' && Number.isFinite(specific) && specific > 0) {
+        return Math.floor(specific);
+    }
+    const fallback = runtime.defaultContextTokens ?? runtime.maxContextTokens;
+    if (typeof fallback === 'number' && Number.isFinite(fallback) && fallback > 0) {
+        return Math.floor(fallback);
+    }
+    return DEFAULT_MODEL_CONTEXT_TOKENS;
+}
 function normalizeRouting(source) {
     const routing = {};
     for (const [routeName, entries] of Object.entries(source)) {
@@ -209,8 +241,12 @@ function normalizeProvider(providerId, raw) {
                 : '';
     const headers = normalizeHeaders(provider.headers);
     const compatibilityProfile = resolveCompatibilityProfile(providerId, provider);
-    const responsesConfig = normalizeResponsesConfig(provider);
+    const responsesNode = asRecord(provider.responses);
+    const responsesConfig = normalizeResponsesConfig(provider, responsesNode);
     const processMode = normalizeProcessMode(provider.process);
+    const streaming = resolveProviderStreamingPreference(provider, responsesNode);
+    const modelStreaming = normalizeModelStreaming(provider);
+    const { modelContextTokens, defaultContextTokens } = normalizeModelContextTokens(provider);
     return {
         providerId,
         providerType,
@@ -219,59 +255,105 @@ function normalizeProvider(providerId, raw) {
         outboundProfile: mapOutboundProfile(providerType),
         compatibilityProfile,
         processMode,
-        responsesConfig
+        responsesConfig,
+        streaming,
+        modelStreaming,
+        modelContextTokens,
+        defaultContextTokens
     };
 }
-function normalizeResponsesConfig(provider) {
-    const node = asRecord(provider.responses);
-    if (!node) {
+function normalizeModelStreaming(provider) {
+    const modelsNode = asRecord(provider.models);
+    if (!modelsNode) {
         return undefined;
     }
-    const config = {};
-    const rawStyle = typeof node.toolCallIdStyle === 'string' ? node.toolCallIdStyle.trim().toLowerCase() : undefined;
-    if (rawStyle === 'fc' || rawStyle === 'preserve') {
-        config.toolCallIdStyle = rawStyle;
-    }
-    const streaming = normalizeResponsesStreaming(node.streaming);
-    if (streaming) {
-        config.streaming = streaming;
-    }
-    const instructionsMode = normalizeResponsesInstructionsMode(node.instructionsMode);
-    if (instructionsMode) {
-        config.instructionsMode = instructionsMode;
+    const normalized = {};
+    for (const [modelId, modelRaw] of Object.entries(modelsNode)) {
+        if (!modelRaw || typeof modelRaw !== 'object') {
+            continue;
+        }
+        const preference = resolveStreamingPreference(modelRaw);
+        if (preference) {
+            normalized[modelId] = preference;
+        }
     }
-    return Object.keys(config).length ? config : undefined;
+    return Object.keys(normalized).length ? normalized : undefined;
 }
-function normalizeResponsesStreaming(value) {
-    if (value === true) {
-        return 'always';
-    }
-    if (value === false) {
-        return 'never';
+function normalizeModelContextTokens(provider) {
+    const modelsNode = asRecord(provider.models);
+    const normalized = {};
+    for (const [modelId, modelRaw] of Object.entries(modelsNode)) {
+        if (!modelRaw || typeof modelRaw !== 'object') {
+            continue;
+        }
+        const candidate = readContextTokens(modelRaw);
+        if (candidate) {
+            normalized[modelId] = candidate;
+        }
     }
+    const configNode = asRecord(provider.config);
+    const defaultsNode = asRecord(configNode?.userConfigDefaults);
+    const defaultCandidate = readContextTokens(provider) ??
+        readContextTokens(configNode) ??
+        readContextTokens(defaultsNode);
+    return {
+        modelContextTokens: Object.keys(normalized).length ? normalized : undefined,
+        defaultContextTokens: defaultCandidate
+    };
+}
+function resolveStreamingPreference(model) {
+    return (coerceStreamingPreference(model.streaming) ??
+        coerceStreamingPreference(model.stream) ??
+        coerceStreamingPreference(model.supportsStreaming));
+}
+function coerceStreamingPreference(value) {
     if (typeof value === 'string') {
         const normalized = value.trim().toLowerCase();
-        if (normalized === 'always' || normalized === 'true' || normalized === '1' || normalized === 'yes') {
+        if (normalized === 'always' || normalized === 'auto' || normalized === 'never') {
+            return normalized;
+        }
+        if (normalized === 'true') {
             return 'always';
         }
-        if (normalized === 'never' || normalized === 'false' || normalized === '0' || normalized === 'no') {
+        if (normalized === 'false') {
             return 'never';
         }
-        if (normalized === 'auto') {
-            return 'auto';
+    }
+    if (typeof value === 'boolean') {
+        return value ? 'always' : 'never';
+    }
+    if (value && typeof value === 'object') {
+        const record = value;
+        if (record.mode !== undefined) {
+            return coerceStreamingPreference(record.mode);
+        }
+        if (record.value !== undefined) {
+            return coerceStreamingPreference(record.value);
+        }
+        if (record.enabled !== undefined) {
+            return coerceStreamingPreference(record.enabled);
         }
     }
     return undefined;
 }
-function normalizeResponsesInstructionsMode(value) {
-    if (value === 'inline') {
-        return 'inline';
+function normalizeResponsesConfig(provider, node) {
+    const source = node ?? asRecord(provider.responses);
+    if (!source) {
+        return undefined;
     }
-    if (typeof value === 'string' && value.trim().toLowerCase() === 'inline') {
-        return 'inline';
+    const rawStyle = typeof source.toolCallIdStyle === 'string' ? source.toolCallIdStyle.trim().toLowerCase() : undefined;
+    if (rawStyle === 'fc' || rawStyle === 'preserve') {
+        return { toolCallIdStyle: rawStyle };
     }
     return undefined;
 }
+function resolveProviderStreamingPreference(provider, responsesNode) {
+    const configNode = asRecord(provider.config);
+    const configResponses = configNode ? asRecord(configNode.responses) : undefined;
+    return (coerceStreamingPreference(provider.streaming ?? provider.stream ?? provider.supportsStreaming ?? provider.streamingPreference) ??
+        coerceStreamingPreference(responsesNode?.streaming ?? responsesNode?.stream ?? responsesNode?.supportsStreaming) ??
+        coerceStreamingPreference(configResponses?.streaming ?? configResponses?.stream));
+}
 function resolveCompatibilityProfile(providerId, provider) {
     if (typeof provider.compatibilityProfile === 'string' && provider.compatibilityProfile.trim()) {
         return provider.compatibilityProfile.trim();
@@ -298,6 +380,26 @@ function normalizeProcessMode(value) {
     }
     return 'chat';
 }
+function normalizeContextRouting(input) {
+    if (!input || typeof input !== 'object') {
+        return { ...DEFAULT_CONTEXT_ROUTING };
+    }
+    const record = input;
+    const warnCandidate = coerceRatio(record.warnRatio) ??
+        coerceRatio(record?.warn_ratio);
+    const hardLimitCandidate = coerceBoolean(record.hardLimit) ??
+        coerceBoolean(record?.hard_limit);
+    const fallbackCandidate = readOptionalString(record.fallbackRoute) ??
+        readOptionalString(record?.fallback_route);
+    const warnRatio = clampWarnRatio(warnCandidate ?? DEFAULT_CONTEXT_ROUTING.warnRatio);
+    const hardLimit = typeof hardLimitCandidate === 'boolean' ? hardLimitCandidate : DEFAULT_CONTEXT_ROUTING.hardLimit;
+    const fallbackRoute = fallbackCandidate ?? DEFAULT_CONTEXT_ROUTING.fallbackRoute;
+    return {
+        warnRatio,
+        hardLimit,
+        fallbackRoute
+    };
+}
 function extractProviderAuthEntries(providerId, raw) {
     const provider = asRecord(raw);
     const auth = asRecord(provider.auth);
@@ -428,6 +530,25 @@ function extractProviderAuthEntries(providerId, raw) {
     else if (typeof apiKeyField === 'string' && apiKeyField.trim()) {
         pushEntry(undefined, buildAuthCandidate(baseTypeSource, { value: apiKeyField.trim() }));
     }
+    // 自动多 token 扫描：仅在未显式声明多 key、且为受支持的 OAuth 提供方时触发
+    if (!entries.length && baseType === 'oauth') {
+        const oauthProviderId = baseTypeInfo.oauthProviderId;
+        if (oauthProviderId && MULTI_TOKEN_OAUTH_PROVIDERS.has(oauthProviderId)) {
+            const tokenFiles = scanOAuthTokenFiles(oauthProviderId);
+            for (const match of tokenFiles) {
+                const alias = match.alias && match.alias !== 'default'
+                    ? `${match.sequence}-${match.alias}`
+                    : String(match.sequence);
+                const authConfig = {
+                    ...defaults,
+                    type: baseTypeSource ?? `${oauthProviderId}-oauth`,
+                    tokenFile: match.filePath,
+                    oauthProviderId
+                };
+                pushEntry(alias, authConfig);
+            }
+        }
+    }
     if (!entries.length) {
         const fallbackExtras = {
             value: readOptionalString(auth.value),
@@ -591,6 +712,7 @@ function mergeScopes(primary, fallback) {
     }
     return merged.size ? Array.from(merged) : undefined;
 }
+const MULTI_TOKEN_OAUTH_PROVIDERS = new Set(['iflow']);
 function interpretAuthType(value) {
     if (typeof value !== 'string') {
         return { type: 'apiKey' };
@@ -634,6 +756,47 @@ function normalizeLoadBalancing(input) {
         ? { strategy, weights: weightsEntries }
         : { strategy };
 }
+function coerceRatio(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (!trimmed) {
+            return undefined;
+        }
+        const parsed = Number(trimmed);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return undefined;
+}
+function clampWarnRatio(value) {
+    if (!Number.isFinite(value)) {
+        return DEFAULT_CONTEXT_ROUTING.warnRatio;
+    }
+    const clamped = Math.max(0.1, Math.min(value, 0.99));
+    return Number.isFinite(clamped) ? clamped : DEFAULT_CONTEXT_ROUTING.warnRatio;
+}
+function coerceBoolean(value) {
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        const normalized = value.trim().toLowerCase();
+        if (!normalized) {
+            return undefined;
+        }
+        if (['true', '1', 'yes', 'y'].includes(normalized)) {
+            return true;
+        }
+        if (['false', '0', 'no', 'n'].includes(normalized)) {
+            return false;
+        }
+    }
+    return undefined;
+}
 function normalizeHealth(input) {
     if (!input || typeof input !== 'object')
         return undefined;
@@ -648,6 +811,43 @@ function normalizeHealth(input) {
         ? { failureThreshold, cooldownMs, fatalCooldownMs }
         : { failureThreshold, cooldownMs };
 }
+function readContextTokens(record) {
+    if (!record) {
+        return undefined;
+    }
+    const keys = [
+        'maxContextTokens',
+        'max_context_tokens',
+        'maxContext',
+        'max_context',
+        'contextTokens',
+        'context_tokens'
+    ];
+    for (const key of keys) {
+        const value = record[key];
+        const parsed = normalizePositiveInteger(value);
+        if (parsed) {
+            return parsed;
+        }
+    }
+    return undefined;
+}
+function normalizePositiveInteger(value) {
+    if (typeof value === 'number' && Number.isFinite(value) && value > 0) {
+        return Math.floor(value);
+    }
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (!trimmed) {
+            return undefined;
+        }
+        const parsed = Number(trimmed);
+        if (Number.isFinite(parsed) && parsed > 0) {
+            return Math.floor(parsed);
+        }
+    }
+    return undefined;
+}
 function normalizeHeaders(input) {
     if (!input || typeof input !== 'object') {
         return undefined;

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

@@ -1,18 +1,5 @@
 import { DEFAULT_ROUTE, ROUTE_PRIORITY } from './types.js';
 const DEFAULT_LONG_CONTEXT_THRESHOLD = 180000;
-const WEBSEARCH_HINT_KEYWORDS = [
-    'web search',
-    'search the web',
-    'search online',
-    'internet search',
-    'search internet',
-    'google it',
-    'bing it',
-    '网络搜索',
-    '上网搜索',
-    '查一下网络',
-    '搜一下网络'
-];
 export class RoutingClassifier {
     config;
     constructor(config) {
@@ -24,33 +11,20 @@ export class RoutingClassifier {
     }
     classify(features) {
         const lastToolCategory = features.lastAssistantToolCategory;
-        const toolCategories = features.assistantToolCategories ?? [];
-        const hasSearchToolCall = toolCategories.includes('search');
-        const hasWriteToolCall = toolCategories.includes('write');
-        const hasReadToolCall = toolCategories.includes('read');
-        const hasOtherToolCall = toolCategories.includes('other');
-        const hasToolCall = toolCategories.length > 0;
         const reachedLongContext = features.estimatedTokens >= (this.config.longContextThresholdTokens ?? DEFAULT_LONG_CONTEXT_THRESHOLD);
-        const routeHint = typeof features.metadata?.routeHint === 'string'
-            ? features.metadata.routeHint.trim().toLowerCase()
-            : undefined;
-        const websearchKeywordHit = containsKeywords(features.userTextSample, WEBSEARCH_HINT_KEYWORDS);
-        const codingContinuation = hasWriteToolCall || lastToolCategory === 'write';
-        const readingContinuation = hasReadToolCall || lastToolCategory === 'read';
-        const userInputDetected = typeof features.userTextSample === 'string'
-            ? features.userTextSample.trim().length > 0
-            : false;
-        const searchContinuation = features.assistantCalledWebSearchTool === true || hasSearchToolCall;
-        const toolsContinuation = hasOtherToolCall ||
-            searchContinuation ||
-            (hasToolCall && !hasWriteToolCall && !readingContinuation);
-        const toolContinuationReason = hasOtherToolCall
-            ? formatToolContinuationReason(features.lastAssistantToolName, features.lastAssistantToolDetail)
-            : searchContinuation
-                ? 'tools:last-tool-search'
-                : 'tools:tool-call-detected';
-        const thinkingContinuation = readingContinuation || (Boolean(features.hasThinkingKeyword) && !toolsContinuation && !codingContinuation);
-        const thinkingReason = readingContinuation ? 'thinking:last-tool-read' : 'thinking:keywords';
+        const latestMessageFromUser = features.latestMessageFromUser === true;
+        const codingContinuation = lastToolCategory === 'write';
+        const thinkingContinuation = lastToolCategory === 'read';
+        const searchContinuation = lastToolCategory === 'search';
+        const toolsContinuation = lastToolCategory === 'other';
+        if (latestMessageFromUser) {
+            const reasoning = 'thinking:user-input';
+            const evaluations = {
+                thinking: { triggered: true, reason: reasoning }
+            };
+            const candidates = this.ensureDefaultCandidate(['thinking']);
+            return this.buildResult('thinking', reasoning, evaluations, candidates);
+        }
         const evaluationMap = {
             vision: {
                 triggered: features.hasVisionTool && features.hasImageAttachment,
@@ -61,20 +35,20 @@ export class RoutingClassifier {
                 reason: 'longcontext:token-threshold'
             },
             websearch: {
-                triggered: routeHint === 'websearch' || websearchKeywordHit,
-                reason: routeHint === 'websearch' ? 'websearch:route-hint' : 'websearch:keywords'
+                triggered: features.hasWebTool || searchContinuation,
+                reason: searchContinuation ? 'websearch:last-tool-search' : 'websearch:web-tools-detected'
             },
             coding: {
                 triggered: codingContinuation,
                 reason: 'coding:last-tool-write'
             },
             thinking: {
-                triggered: thinkingContinuation,
-                reason: thinkingReason
+                triggered: thinkingContinuation || latestMessageFromUser,
+                reason: thinkingContinuation ? 'thinking:last-tool-read' : 'thinking:user-input'
             },
             tools: {
-                triggered: toolsContinuation,
-                reason: toolContinuationReason
+                triggered: toolsContinuation || features.hasTools || features.hasToolCallResponses,
+                reason: toolsContinuation ? 'tools:last-tool-other' : 'tools:tool-request-detected'
             },
             background: {
                 triggered: containsKeywords(features.userTextSample, this.config.backgroundKeywords ?? []),
@@ -133,9 +107,3 @@ function containsKeywords(text, keywords) {
     const normalized = text.toLowerCase();
     return keywords.some((keyword) => normalized.includes(keyword));
 }
-function formatToolContinuationReason(toolName, toolDetail) {
-    const trimmedName = toolName?.trim() || 'tool';
-    const trimmedDetail = toolDetail?.trim();
-    const detailText = trimmedDetail ? `${trimmedName}: ${trimmedDetail}` : trimmedName;
-    return `tools:last-tool-other(${detailText})`;
-}

package/dist/router/virtual-router/context-advisor.d.ts

@@ -0,0 +1,21 @@
+import { type ProviderProfile, type VirtualRouterContextRoutingConfig } from './types.js';
+export interface ContextUsageSnapshot {
+    ratio: number;
+    limit: number;
+}
+export interface ContextAdvisorResult {
+    safe: string[];
+    risky: string[];
+    overflow: string[];
+    usage: Record<string, ContextUsageSnapshot>;
+    estimatedTokens: number;
+    allOverflow: boolean;
+}
+export declare class ContextAdvisor {
+    private warnRatio;
+    private hardLimit;
+    configure(config?: VirtualRouterContextRoutingConfig | null): void;
+    classify(pool: string[], estimatedTokens: number, resolveProfile: (key: string) => ProviderProfile): ContextAdvisorResult;
+    prefersFallback(result: ContextAdvisorResult): boolean;
+    allowsOverflow(): boolean;
+}

package/dist/router/virtual-router/context-advisor.js

@@ -0,0 +1,76 @@
+import { DEFAULT_MODEL_CONTEXT_TOKENS } from './types.js';
+const DEFAULT_WARN_RATIO = 0.9;
+export class ContextAdvisor {
+    warnRatio = DEFAULT_WARN_RATIO;
+    hardLimit = false;
+    configure(config) {
+        if (config && typeof config.warnRatio === 'number' && Number.isFinite(config.warnRatio)) {
+            this.warnRatio = clampWarnRatio(config.warnRatio);
+        }
+        else {
+            this.warnRatio = DEFAULT_WARN_RATIO;
+        }
+        this.hardLimit = Boolean(config?.hardLimit);
+    }
+    classify(pool, estimatedTokens, resolveProfile) {
+        const normalizedTokens = typeof estimatedTokens === 'number' && Number.isFinite(estimatedTokens) && estimatedTokens > 0
+            ? estimatedTokens
+            : 0;
+        const safe = [];
+        const risky = [];
+        const overflow = [];
+        const usage = {};
+        for (const providerKey of pool) {
+            let limit = DEFAULT_MODEL_CONTEXT_TOKENS;
+            try {
+                const profile = resolveProfile(providerKey);
+                if (profile?.maxContextTokens && Number.isFinite(profile.maxContextTokens)) {
+                    limit = profile.maxContextTokens;
+                }
+            }
+            catch {
+                limit = DEFAULT_MODEL_CONTEXT_TOKENS;
+            }
+            if (!limit || limit <= 0) {
+                limit = DEFAULT_MODEL_CONTEXT_TOKENS;
+            }
+            const ratio = limit > 0 ? normalizedTokens / limit : 0;
+            usage[providerKey] = { ratio, limit };
+            if (normalizedTokens === 0 || ratio < this.warnRatio) {
+                safe.push(providerKey);
+                continue;
+            }
+            if (ratio < 1) {
+                risky.push(providerKey);
+                continue;
+            }
+            overflow.push(providerKey);
+        }
+        return {
+            safe,
+            risky,
+            overflow,
+            usage,
+            estimatedTokens: normalizedTokens,
+            allOverflow: safe.length === 0 && risky.length === 0 && overflow.length > 0
+        };
+    }
+    prefersFallback(result) {
+        if (result.safe.length > 0) {
+            return false;
+        }
+        if (result.risky.length > 0) {
+            return true;
+        }
+        return result.allOverflow;
+    }
+    allowsOverflow() {
+        return !this.hardLimit;
+    }
+}
+function clampWarnRatio(value) {
+    if (!Number.isFinite(value)) {
+        return DEFAULT_WARN_RATIO;
+    }
+    return Math.max(0.1, Math.min(0.99, value));
+}

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

@@ -6,12 +6,11 @@ export declare class VirtualRouterEngine {
     private readonly healthManager;
     private loadBalancer;
     private classifier;
+    private readonly contextAdvisor;
+    private contextRouting;
     private routeStats;
     private readonly debug;
     private healthConfig;
-    private stickyPlans;
-    private selectionHistory;
-    private providerErrorStreaks;
     initialize(config: VirtualRouterConfig): void;
     route(request: StandardizedRequest | ProcessedRequest, metadata: RouterMetadataInput): {
         target: TargetMetadata;
@@ -28,39 +27,24 @@ export declare class VirtualRouterEngine {
         }>;
         health: import("./types.js").ProviderHealthState[];
     };
-    private consumeSticky;
-    private selectStickyTarget;
-    private buildStickyClassification;
-    private recordSelectionSnapshot;
-    private buildStickyPlan;
-    private storeStickyPlan;
-    private dropStickyForRequest;
-    private resolveStickyDescriptor;
-    private maybeForceStickyFromHistory;
-    private shouldForceApplyPatchSticky;
-    private extractPreviousRequestId;
-    private pruneStickyPlans;
-    private buildErrorSignature;
-    private bumpProviderErrorStreak;
-    private resetProviderErrorStreak;
     private validateConfig;
     private selectProvider;
     private incrementRouteStat;
     private providerHealthConfig;
+    private initializeRouteQueue;
+    private resolveFallbackRoute;
+    private maybeDeferToFallback;
+    private buildContextCandidatePools;
+    private describeAttempt;
     private resolveStickyKey;
     private mapProviderError;
     private deriveReason;
     private buildRouteCandidates;
-    private ensureConfiguredClassification;
-    private normalizeCandidateList;
-    private normalizeRouteName;
-    private isRouteConfigured;
     private sortByPriority;
     private routeWeight;
     private buildHitReason;
-    private formatToolIdentifier;
-    private decorateReason;
-    private buildVirtualRouterHitLog;
-    private colorizeVirtualRouterLog;
-    private shouldColorVirtualRouterLogs;
+    private decorateWithDetail;
+    private formatVirtualRouterHit;
+    private resolveRouteColor;
+    private describeContextUsage;
 }