@jsonstudio/rcc 0.89.168 → 0.89.524

package/node_modules/@jsonstudio/llms/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,10 @@ 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
+};
 /**
  * 将用户提供的 Virtual Router 配置（或包含 virtualrouter 字段的整体配置）
  * 规范化为 VirtualRouterConfig，供 HubPipeline / VirtualRouterEngine 直接使用。
@@ -22,6 +27,8 @@ export function bootstrapVirtualRouterConfig(input) {
     if (!Object.keys(routingSource).length) {
         throw new VirtualRouterError('Virtual Router routing table cannot be empty', VirtualRouterErrorCode.CONFIG_ERROR);
     }
+    const webSearch = normalizeWebSearch(section.webSearch, routingSource);
+    validateWebSearchRouting(webSearch, routingSource);
     const { runtimeEntries, aliasIndex } = buildProviderRuntimeEntries(providersSource);
     const { routing, targetKeys } = expandRoutingTable(routingSource, aliasIndex);
     if (!routing.default || routing.default.length === 0) {
@@ -31,12 +38,15 @@ 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,
+        ...(webSearch ? { webSearch } : {})
     };
     return {
         config,
@@ -56,7 +66,9 @@ 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);
+    const webSearch = section.webSearch ?? root.webSearch;
+    return { providers, routing, classifier, loadBalancing, health, contextRouting, webSearch };
 }
 function buildProviderRuntimeEntries(providers) {
     const runtimeEntries = {};
@@ -86,6 +98,11 @@ function buildProviderRuntimeEntries(providers) {
                 userInfoUrl: entry.auth.userInfoUrl,
                 refreshUrl: entry.auth.refreshUrl
             };
+            // 为 OAuth 类型的 auth 设置 tokenFile 为 alias（如果没有显式配置 tokenFile）
+            // 这允许 oauth-lifecycle.ts 的 resolveTokenFilePath 函数正确解析并匹配现有文件
+            if (!runtimeAuth.tokenFile && (runtimeAuth.rawType?.includes('oauth') || runtimeAuth.type === 'oauth')) {
+                runtimeAuth.tokenFile = entry.keyAlias;
+            }
             if (runtimeAuth.type === 'apiKey' && !runtimeAuth.secretRef) {
                 runtimeAuth.secretRef = `${providerId}.${entry.keyAlias}`;
             }
@@ -100,7 +117,12 @@ 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,
+                ...(normalizedProvider.serverToolsDisabled ? { serverToolsDisabled: true } : {})
             };
         }
     }
@@ -109,28 +131,40 @@ function buildProviderRuntimeEntries(providers) {
 function expandRoutingTable(routingSource, aliasIndex) {
     const routing = {};
     const targetKeys = new Set();
-    for (const [routeName, entries] of Object.entries(routingSource)) {
-        const expanded = [];
-        for (const entry of entries) {
-            const parsed = parseRouteEntry(entry, aliasIndex);
-            if (!parsed) {
-                continue;
-            }
-            if (!aliasIndex.has(parsed.providerId)) {
-                throw new VirtualRouterError(`Route "${routeName}" references unknown provider "${parsed.providerId}"`, VirtualRouterErrorCode.CONFIG_ERROR);
-            }
-            const aliases = parsed.keyAlias ? [parsed.keyAlias] : aliasIndex.get(parsed.providerId);
-            if (!aliases.length) {
-                throw new VirtualRouterError(`Provider ${parsed.providerId} has no auth aliases but is referenced in routing`, VirtualRouterErrorCode.CONFIG_ERROR);
+    for (const [routeName, pools] of Object.entries(routingSource)) {
+        const expandedPools = [];
+        for (const pool of pools) {
+            const expandedTargets = [];
+            for (const entry of pool.targets) {
+                const parsed = parseRouteEntry(entry, aliasIndex);
+                if (!parsed) {
+                    continue;
+                }
+                if (!aliasIndex.has(parsed.providerId)) {
+                    throw new VirtualRouterError(`Route "${routeName}" references unknown provider "${parsed.providerId}"`, VirtualRouterErrorCode.CONFIG_ERROR);
+                }
+                const aliases = parsed.keyAlias ? [parsed.keyAlias] : aliasIndex.get(parsed.providerId);
+                if (!aliases.length) {
+                    throw new VirtualRouterError(`Provider ${parsed.providerId} has no auth aliases but is referenced in routing`, VirtualRouterErrorCode.CONFIG_ERROR);
+                }
+                for (const alias of aliases) {
+                    const runtimeKey = buildRuntimeKey(parsed.providerId, alias);
+                    const targetKey = `${runtimeKey}.${parsed.modelId}`;
+                    pushUnique(expandedTargets, targetKey);
+                    targetKeys.add(targetKey);
+                }
             }
-            for (const alias of aliases) {
-                const runtimeKey = buildRuntimeKey(parsed.providerId, alias);
-                const targetKey = `${runtimeKey}.${parsed.modelId}`;
-                pushUnique(expanded, targetKey);
-                targetKeys.add(targetKey);
+            if (expandedTargets.length) {
+                expandedPools.push({
+                    id: pool.id,
+                    priority: pool.priority,
+                    backup: pool.backup,
+                    targets: expandedTargets,
+                    ...(pool.force ? { force: true } : {})
+                });
             }
         }
-        routing[routeName] = expanded;
+        routing[routeName] = expandedPools;
     }
     return { routing, targetKeys };
 }
@@ -146,6 +180,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,27 +194,166 @@ function buildProviderProfiles(targetKeys, runtimeEntries) {
             runtimeKey,
             modelId: parsed.modelId,
             processMode: runtime.processMode || 'chat',
-            responsesConfig: runtime.responsesConfig
+            responsesConfig: runtime.responsesConfig,
+            streaming: streamingPref,
+            maxContextTokens: contextTokens,
+            ...(runtime.serverToolsDisabled ? { serverToolsDisabled: true } : {})
         };
         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)) {
-        if (!Array.isArray(entries))
+        if (!Array.isArray(entries) || !entries.length) {
+            routing[routeName] = [];
             continue;
-        const normalized = entries
-            .map((entry) => (typeof entry === 'string' ? entry.trim() : ''))
-            .filter(Boolean);
-        routing[routeName] = Array.from(new Set(normalized));
+        }
+        const allStrings = entries.every((entry) => typeof entry === 'string' || entry === null || entry === undefined);
+        if (allStrings) {
+            const targets = normalizeTargetList(entries);
+            routing[routeName] = targets.length ? [buildLegacyRoutePool(routeName, targets)] : [];
+            continue;
+        }
+        const normalized = [];
+        const total = entries.length || 1;
+        for (let index = 0; index < entries.length; index += 1) {
+            const entry = entries[index];
+            const pool = normalizeRoutePoolEntry(routeName, entry, index, total);
+            if (pool && pool.targets.length) {
+                normalized.push(pool);
+            }
+        }
+        routing[routeName] = normalized;
     }
     return routing;
 }
+function buildLegacyRoutePool(routeName, targets) {
+    return {
+        id: `${routeName}:pool0`,
+        priority: targets.length,
+        backup: false,
+        targets
+    };
+}
+function normalizeRoutePoolEntry(routeName, entry, index, total) {
+    if (typeof entry === 'string') {
+        const targets = normalizeTargetList(entry);
+        return targets.length
+            ? {
+                id: `${routeName}:pool${index + 1}`,
+                priority: total - index,
+                backup: false,
+                targets
+            }
+            : null;
+    }
+    if (!entry || typeof entry !== 'object') {
+        return null;
+    }
+    const record = entry;
+    const id = readOptionalString(record.id) ??
+        readOptionalString(record?.poolId) ??
+        `${routeName}:pool${index + 1}`;
+    const backup = record.backup === true ||
+        record.isBackup === true ||
+        (typeof record.type === 'string' && record.type.toLowerCase() === 'backup');
+    const priority = normalizePriorityValue(record.priority, total - index);
+    const targets = normalizeRouteTargets(record);
+    const force = record.force === true ||
+        (typeof record.force === 'string' && record.force.trim().toLowerCase() === 'true');
+    return targets.length
+        ? {
+            id,
+            priority,
+            backup,
+            targets,
+            ...(force ? { force: true } : {})
+        }
+        : null;
+}
+function normalizeRouteTargets(record) {
+    const buckets = [
+        record.targets,
+        record.providers,
+        record.pool,
+        record.entries,
+        record.items,
+        record.routes
+    ];
+    const normalized = [];
+    for (const bucket of buckets) {
+        for (const target of normalizeTargetList(bucket)) {
+            if (!normalized.includes(target)) {
+                normalized.push(target);
+            }
+        }
+    }
+    const singular = [record.target, record.provider];
+    for (const candidate of singular) {
+        for (const target of normalizeTargetList(candidate)) {
+            if (!normalized.includes(target)) {
+                normalized.push(target);
+            }
+        }
+    }
+    return normalized;
+}
+function normalizeTargetList(value) {
+    if (Array.isArray(value)) {
+        const normalized = [];
+        for (const entry of value) {
+            if (typeof entry === 'string') {
+                const trimmed = entry.trim();
+                if (trimmed && !normalized.includes(trimmed)) {
+                    normalized.push(trimmed);
+                }
+            }
+        }
+        return normalized;
+    }
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        return trimmed ? [trimmed] : [];
+    }
+    if (typeof value === 'number') {
+        const str = String(value).trim();
+        return str ? [str] : [];
+    }
+    return [];
+}
+function normalizePriorityValue(value, fallback) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (trimmed) {
+            const parsed = Number(trimmed);
+            if (Number.isFinite(parsed)) {
+                return parsed;
+            }
+        }
+    }
+    return fallback;
+}
 function normalizeClassifier(input) {
     const normalized = asRecord(input);
     const result = {
@@ -209,8 +386,18 @@ 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);
+    const serverToolsDisabled = provider.serverToolsDisabled === true ||
+        (typeof provider.serverToolsDisabled === 'string' &&
+            provider.serverToolsDisabled.trim().toLowerCase() === 'true') ||
+        (provider.serverTools &&
+            typeof provider.serverTools === 'object' &&
+            provider.serverTools.enabled === false);
     return {
         providerId,
         providerType,
@@ -219,20 +406,106 @@ function normalizeProvider(providerId, raw) {
         outboundProfile: mapOutboundProfile(providerType),
         compatibilityProfile,
         processMode,
-        responsesConfig
+        responsesConfig,
+        streaming,
+        modelStreaming,
+        modelContextTokens,
+        defaultContextTokens,
+        ...(serverToolsDisabled ? { serverToolsDisabled: true } : {})
+    };
+}
+function normalizeModelStreaming(provider) {
+    const modelsNode = asRecord(provider.models);
+    if (!modelsNode) {
+        return undefined;
+    }
+    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(normalized).length ? normalized : undefined;
+}
+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 normalizeResponsesConfig(provider) {
-    const node = asRecord(provider.responses);
-    if (!node) {
+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 === 'auto' || normalized === 'never') {
+            return normalized;
+        }
+        if (normalized === 'true') {
+            return 'always';
+        }
+        if (normalized === 'false') {
+            return 'never';
+        }
+    }
+    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 normalizeResponsesConfig(provider, node) {
+    const source = node ?? asRecord(provider.responses);
+    if (!source) {
         return undefined;
     }
-    const rawStyle = typeof node.toolCallIdStyle === 'string' ? node.toolCallIdStyle.trim().toLowerCase() : undefined;
+    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();
@@ -259,6 +532,121 @@ 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 warnRatio = clampWarnRatio(warnCandidate ?? DEFAULT_CONTEXT_ROUTING.warnRatio);
+    const hardLimit = typeof hardLimitCandidate === 'boolean' ? hardLimitCandidate : DEFAULT_CONTEXT_ROUTING.hardLimit;
+    return {
+        warnRatio,
+        hardLimit
+    };
+}
+function validateWebSearchRouting(webSearch, routingSource) {
+    if (!webSearch) {
+        return;
+    }
+    const routePools = routingSource['web_search'] ?? routingSource['search'];
+    if (!Array.isArray(routePools) || !routePools.length) {
+        throw new VirtualRouterError('Virtual Router webSearch.engines configured but routing.web_search (or search) route is missing or empty', VirtualRouterErrorCode.CONFIG_ERROR);
+    }
+    const targets = new Set();
+    for (const pool of routePools) {
+        if (!pool || !Array.isArray(pool.targets)) {
+            continue;
+        }
+        for (const target of pool.targets) {
+            if (typeof target === 'string' && target.trim()) {
+                targets.add(target.trim());
+            }
+        }
+    }
+    for (const engine of webSearch.engines) {
+        if (!targets.has(engine.providerKey)) {
+            throw new VirtualRouterError(`Virtual Router webSearch engine "${engine.id}" references providerKey "${engine.providerKey}" which is not present in routing.web_search/search`, VirtualRouterErrorCode.CONFIG_ERROR);
+        }
+    }
+}
+function normalizeWebSearch(input, routingSource) {
+    if (!input || typeof input !== 'object') {
+        return undefined;
+    }
+    const record = input;
+    const enginesNode = Array.isArray(record.engines) ? record.engines : [];
+    const engines = [];
+    for (const raw of enginesNode) {
+        if (!raw || typeof raw !== 'object') {
+            continue;
+        }
+        const node = raw;
+        const idRaw = node.id;
+        const providerKeyRaw = node.providerKey ?? node.provider ?? node.target;
+        const id = typeof idRaw === 'string' && idRaw.trim()
+            ? idRaw.trim()
+            : undefined;
+        const providerKey = typeof providerKeyRaw === 'string' && providerKeyRaw.trim()
+            ? providerKeyRaw.trim()
+            : undefined;
+        if (!id || !providerKey) {
+            continue;
+        }
+        const description = typeof node.description === 'string' && node.description.trim()
+            ? node.description.trim()
+            : undefined;
+        const isDefault = node.default === true ||
+            (typeof node.default === 'string' && node.default.trim().toLowerCase() === 'true');
+        const serverToolsDisabled = node.serverToolsDisabled === true ||
+            (typeof node.serverToolsDisabled === 'string' &&
+                node.serverToolsDisabled.trim().toLowerCase() === 'true') ||
+            (node.serverTools &&
+                typeof node.serverTools === 'object' &&
+                node.serverTools.enabled === false);
+        // Deduplicate by id; first wins, subsequent are ignored.
+        if (engines.some((engine) => engine.id === id)) {
+            continue;
+        }
+        engines.push({
+            id,
+            providerKey,
+            description,
+            default: isDefault,
+            ...(serverToolsDisabled ? { serverToolsDisabled: true } : {})
+        });
+    }
+    if (!engines.length) {
+        return undefined;
+    }
+    let injectPolicy;
+    let force;
+    const rawPolicy = record.injectPolicy ?? record?.inject_policy;
+    if (typeof rawPolicy === 'string') {
+        const normalized = rawPolicy.trim().toLowerCase();
+        if (normalized === 'always' || normalized === 'selective') {
+            injectPolicy = normalized;
+        }
+    }
+    if (record.force === true ||
+        (typeof record.force === 'string' && record.force.trim().toLowerCase() === 'true')) {
+        force = true;
+    }
+    else {
+        const webSearchPools = routingSource['web_search'] ?? routingSource['search'] ?? [];
+        if (Array.isArray(webSearchPools) && webSearchPools.some((pool) => pool.force)) {
+            force = true;
+        }
+    }
+    return {
+        engines,
+        injectPolicy: injectPolicy ?? 'selective',
+        ...(force ? { force } : {})
+    };
+}
 function extractProviderAuthEntries(providerId, raw) {
     const provider = asRecord(raw);
     const auth = asRecord(provider.auth);
@@ -389,6 +777,43 @@ function extractProviderAuthEntries(providerId, raw) {
     else if (typeof apiKeyField === 'string' && apiKeyField.trim()) {
         pushEntry(undefined, buildAuthCandidate(baseTypeSource, { value: apiKeyField.trim() }));
     }
+    // 自动多 token 扫描：仅在未显式声明多 key、且为受支持的 OAuth 提供方时触发
+    if (baseType === 'oauth') {
+        const scanCandidates = new Set();
+        const pushCandidate = (value) => {
+            if (typeof value === 'string' && value.trim()) {
+                scanCandidates.add(value.trim().toLowerCase());
+            }
+        };
+        pushCandidate(auth?.oauthProviderId);
+        pushCandidate(baseTypeInfo.oauthProviderId);
+        pushCandidate(providerId);
+        for (const candidate of scanCandidates) {
+            if (!MULTI_TOKEN_OAUTH_PROVIDERS.has(candidate)) {
+                continue;
+            }
+            const tokenFiles = scanOAuthTokenFiles(candidate);
+            if (!tokenFiles.length) {
+                continue;
+            }
+            const baseTypeAlias = baseTypeInfo.oauthProviderId?.toLowerCase();
+            for (const match of tokenFiles) {
+                const alias = match.alias && match.alias !== 'default'
+                    ? `${match.sequence}-${match.alias}`
+                    : String(match.sequence);
+                const typeHint = baseTypeSource && baseTypeAlias === candidate
+                    ? baseTypeSource
+                    : `${candidate}-oauth`;
+                const authConfig = {
+                    ...defaults,
+                    type: typeHint,
+                    tokenFile: match.filePath,
+                    oauthProviderId: candidate
+                };
+                pushEntry(alias, authConfig);
+            }
+        }
+    }
     if (!entries.length) {
         const fallbackExtras = {
             value: readOptionalString(auth.value),
@@ -552,6 +977,7 @@ function mergeScopes(primary, fallback) {
     }
     return merged.size ? Array.from(merged) : undefined;
 }
+const MULTI_TOKEN_OAUTH_PROVIDERS = new Set(['iflow', 'qwen', 'gemini-cli', 'antigravity']);
 function interpretAuthType(value) {
     if (typeof value !== 'string') {
         return { type: 'apiKey' };
@@ -595,6 +1021,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;
@@ -609,6 +1076,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;