@jsonstudio/rcc 0.89.611 → 0.89.683

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/bootstrap.js

@@ -1,1148 +0,0 @@
-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', '仔细分析', '深度思考'],
-    codingKeywords: ['apply_patch', 'write_file', 'create_file', 'shell', '修改文件', '写入文件'],
-    backgroundKeywords: ['background', 'context dump', '上下文'],
-    visionKeywords: ['vision', 'image', 'picture', 'photo']
-};
-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 直接使用。
- */
-export function bootstrapVirtualRouterConfig(input) {
-    const section = extractVirtualRouterSection(input);
-    const providersSource = asRecord(section.providers);
-    if (!Object.keys(providersSource).length) {
-        throw new VirtualRouterError('Virtual Router requires at least one provider in configuration', VirtualRouterErrorCode.CONFIG_ERROR);
-    }
-    const routingSource = normalizeRouting(section.routing);
-    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) {
-        throw new VirtualRouterError('Virtual Router default route must contain at least one provider target', VirtualRouterErrorCode.CONFIG_ERROR);
-    }
-    const { profiles: providerProfiles, targetRuntime } = buildProviderProfiles(targetKeys, runtimeEntries);
-    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,
-        contextRouting,
-        ...(webSearch ? { webSearch } : {})
-    };
-    return {
-        config,
-        runtime: runtimeEntries,
-        targetRuntime,
-        providers: providerProfiles,
-        routing
-    };
-}
-function extractVirtualRouterSection(input) {
-    const root = asRecord(input);
-    const section = root.virtualrouter && typeof root.virtualrouter === 'object'
-        ? asRecord(root.virtualrouter)
-        : root;
-    const providers = asRecord(section.providers ?? root.providers);
-    const routing = asRecord(section.routing ?? root.routing);
-    const classifier = (section.classifier ?? root.classifier);
-    const loadBalancing = normalizeLoadBalancing(section.loadBalancing ?? root.loadBalancing);
-    const health = normalizeHealth(section.health ?? root.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 = {};
-    const aliasIndex = new Map();
-    for (const [providerId, providerRaw] of Object.entries(providers)) {
-        const normalizedProvider = normalizeProvider(providerId, providerRaw);
-        const authEntries = extractProviderAuthEntries(providerId, providerRaw);
-        if (!authEntries.length) {
-            throw new VirtualRouterError(`Provider ${providerId} requires at least one auth entry`, VirtualRouterErrorCode.CONFIG_ERROR);
-        }
-        aliasIndex.set(providerId, authEntries.map((entry) => entry.keyAlias));
-        for (const entry of authEntries) {
-            const runtimeKey = buildRuntimeKey(providerId, entry.keyAlias);
-            const runtimeAuth = {
-                type: entry.auth.type,
-                rawType: entry.auth.rawType,
-                oauthProviderId: entry.auth.oauthProviderId,
-                secretRef: entry.auth.secretRef,
-                value: entry.auth.value,
-                tokenFile: entry.auth.tokenFile,
-                tokenUrl: entry.auth.tokenUrl,
-                deviceCodeUrl: entry.auth.deviceCodeUrl,
-                clientId: entry.auth.clientId,
-                clientSecret: entry.auth.clientSecret,
-                scopes: entry.auth.scopes && entry.auth.scopes.length ? [...entry.auth.scopes] : undefined,
-                authorizationUrl: entry.auth.authorizationUrl,
-                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}`;
-            }
-            runtimeEntries[runtimeKey] = {
-                runtimeKey,
-                providerId,
-                keyAlias: entry.keyAlias,
-                providerType: normalizedProvider.providerType,
-                endpoint: normalizedProvider.endpoint,
-                headers: normalizedProvider.headers,
-                auth: runtimeAuth,
-                outboundProfile: normalizedProvider.outboundProfile,
-                compatibilityProfile: normalizedProvider.compatibilityProfile,
-                processMode: normalizedProvider.processMode,
-                responsesConfig: normalizedProvider.responsesConfig,
-                streaming: normalizedProvider.streaming,
-                modelStreaming: normalizedProvider.modelStreaming,
-                modelContextTokens: normalizedProvider.modelContextTokens,
-                defaultContextTokens: normalizedProvider.defaultContextTokens,
-                ...(normalizedProvider.serverToolsDisabled ? { serverToolsDisabled: true } : {})
-            };
-        }
-    }
-    return { runtimeEntries, aliasIndex };
-}
-function expandRoutingTable(routingSource, aliasIndex) {
-    const routing = {};
-    const targetKeys = new Set();
-    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);
-                }
-            }
-            if (expandedTargets.length) {
-                expandedPools.push({
-                    id: pool.id,
-                    priority: pool.priority,
-                    backup: pool.backup,
-                    targets: expandedTargets,
-                    ...(pool.force ? { force: true } : {})
-                });
-            }
-        }
-        routing[routeName] = expandedPools;
-    }
-    return { routing, targetKeys };
-}
-function buildProviderProfiles(targetKeys, runtimeEntries) {
-    const profiles = {};
-    const targetRuntime = {};
-    for (const targetKey of targetKeys) {
-        const parsed = parseTargetKey(targetKey);
-        if (!parsed)
-            continue;
-        const runtimeKey = buildRuntimeKey(parsed.providerId, parsed.keyAlias);
-        const runtime = runtimeEntries[runtimeKey];
-        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,
-            endpoint: runtime.endpoint,
-            auth: { ...runtime.auth },
-            outboundProfile: runtime.outboundProfile,
-            compatibilityProfile: runtime.compatibilityProfile,
-            runtimeKey,
-            modelId: parsed.modelId,
-            processMode: runtime.processMode || 'chat',
-            responsesConfig: runtime.responsesConfig,
-            streaming: streamingPref,
-            maxContextTokens: contextTokens,
-            ...(runtime.serverToolsDisabled ? { serverToolsDisabled: true } : {})
-        };
-        targetRuntime[targetKey] = {
-            ...runtime,
-            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) || !entries.length) {
-            routing[routeName] = [];
-            continue;
-        }
-        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 = {
-        longContextThresholdTokens: typeof normalized.longContextThresholdTokens === 'number'
-            ? normalized.longContextThresholdTokens
-            : DEFAULT_CLASSIFIER.longContextThresholdTokens,
-        thinkingKeywords: normalizeStringArray(normalized.thinkingKeywords, DEFAULT_CLASSIFIER.thinkingKeywords),
-        codingKeywords: normalizeStringArray(normalized.codingKeywords, DEFAULT_CLASSIFIER.codingKeywords),
-        backgroundKeywords: normalizeStringArray(normalized.backgroundKeywords, DEFAULT_CLASSIFIER.backgroundKeywords),
-        visionKeywords: normalizeStringArray(normalized.visionKeywords, DEFAULT_CLASSIFIER.visionKeywords)
-    };
-    return result;
-}
-function normalizeStringArray(value, fallback) {
-    if (!Array.isArray(value)) {
-        return [...fallback];
-    }
-    const normalized = value.map((item) => (typeof item === 'string' ? item.trim() : '')).filter(Boolean);
-    return normalized.length ? normalized : [...fallback];
-}
-function normalizeProvider(providerId, raw) {
-    const provider = asRecord(raw);
-    const providerType = detectProviderType(provider);
-    const endpoint = typeof provider.endpoint === 'string' && provider.endpoint.trim()
-        ? provider.endpoint.trim()
-        : typeof provider.baseURL === 'string' && provider.baseURL.trim()
-            ? provider.baseURL.trim()
-            : typeof provider.baseUrl === 'string' && provider.baseUrl.trim()
-                ? provider.baseUrl.trim()
-                : '';
-    const headers = normalizeHeaders(provider.headers);
-    const compatibilityProfile = resolveCompatibilityProfile(providerId, 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,
-        endpoint,
-        headers,
-        outboundProfile: mapOutboundProfile(providerType),
-        compatibilityProfile,
-        processMode,
-        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 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 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();
-    }
-    const legacyFields = [];
-    if (typeof provider.compat === 'string') {
-        legacyFields.push('compat');
-    }
-    if (typeof provider.compatibility_profile === 'string') {
-        legacyFields.push('compatibility_profile');
-    }
-    if (legacyFields.length > 0) {
-        throw new VirtualRouterError(`Provider "${providerId}" uses legacy compatibility field(s): ${legacyFields.join(', ')}. Rename to "compatibilityProfile".`, VirtualRouterErrorCode.CONFIG_ERROR);
-    }
-    return 'compat:passthrough';
-}
-function normalizeProcessMode(value) {
-    if (typeof value !== 'string') {
-        return 'chat';
-    }
-    const normalized = value.trim().toLowerCase();
-    if (normalized === 'passthrough') {
-        return 'passthrough';
-    }
-    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);
-    const entries = [];
-    const aliasSet = new Set();
-    const baseTypeInfo = interpretAuthType(auth.type);
-    const baseType = baseTypeInfo.type;
-    const baseTypeSource = typeof auth.type === 'string' ? auth.type : undefined;
-    const defaults = collectAuthDefaults(auth);
-    const buildAuthCandidate = (typeHint, extras = {}) => {
-        const source = typeof typeHint === 'string' && typeHint.trim()
-            ? typeHint.trim()
-            : baseTypeSource;
-        const typeInfo = interpretAuthType(source ?? baseType);
-        const rawType = typeInfo.raw ?? source ?? baseTypeSource;
-        return {
-            ...extras,
-            type: typeInfo.type,
-            rawType,
-            oauthProviderId: extras?.oauthProviderId ?? typeInfo.oauthProviderId
-        };
-    };
-    const pushEntry = (candidateAlias, authConfig) => {
-        const alias = normalizeAlias(candidateAlias, aliasSet);
-        const typeSource = authConfig?.rawType ??
-            authConfig?.type ??
-            baseTypeSource ??
-            baseType;
-        const typeInfo = interpretAuthType(typeSource);
-        const entryType = typeInfo.type;
-        const oauthProviderId = authConfig?.oauthProviderId ??
-            typeInfo.oauthProviderId ??
-            baseTypeInfo.oauthProviderId;
-        if (entryType === 'oauth' && !oauthProviderId) {
-            throw new VirtualRouterError(`Provider ${providerId} OAuth auth entries must declare provider-specific type (e.g. "qwen-oauth")`, VirtualRouterErrorCode.CONFIG_ERROR);
-        }
-        const normalized = {
-            type: entryType,
-            rawType: typeof typeSource === 'string' ? typeSource : undefined,
-            oauthProviderId,
-            value: readOptionalString(authConfig?.value ?? authConfig?.apiKey),
-            secretRef: readOptionalString(authConfig?.secretRef)
-        };
-        normalized.tokenFile = readOptionalString(authConfig?.tokenFile);
-        normalized.tokenUrl = readOptionalString(authConfig?.tokenUrl ?? authConfig?.token_url);
-        normalized.deviceCodeUrl = readOptionalString(authConfig?.deviceCodeUrl ?? authConfig?.device_code_url);
-        normalized.clientId = readOptionalString(authConfig?.clientId ?? authConfig?.client_id);
-        normalized.clientSecret = readOptionalString(authConfig?.clientSecret ?? authConfig?.client_secret);
-        normalized.authorizationUrl = readOptionalString(authConfig?.authorizationUrl ??
-            authConfig?.authorization_url ??
-            authConfig?.authUrl);
-        normalized.userInfoUrl = readOptionalString(authConfig?.userInfoUrl ?? authConfig?.user_info_url);
-        normalized.refreshUrl = readOptionalString(authConfig?.refreshUrl ?? authConfig?.refresh_url);
-        normalized.scopes = normalizeScopeList(authConfig?.scopes ?? authConfig?.scope);
-        normalized.secretRef ??= defaults.secretRef;
-        normalized.tokenFile ??= defaults.tokenFile;
-        normalized.tokenUrl ??= defaults.tokenUrl;
-        normalized.deviceCodeUrl ??= defaults.deviceCodeUrl;
-        normalized.clientId ??= defaults.clientId;
-        normalized.clientSecret ??= defaults.clientSecret;
-        normalized.authorizationUrl ??= defaults.authorizationUrl;
-        normalized.userInfoUrl ??= defaults.userInfoUrl;
-        normalized.refreshUrl ??= defaults.refreshUrl;
-        normalized.scopes = mergeScopes(normalized.scopes, defaults.scopes);
-        if (entryType === 'apiKey') {
-            if (!normalized.secretRef && normalized.value) {
-                normalized.secretRef = `${providerId}.${alias}`;
-            }
-            else if (!normalized.secretRef) {
-                normalized.secretRef = `${providerId}.${alias}`;
-            }
-        }
-        entries.push({ keyAlias: alias, auth: normalized });
-        aliasSet.add(alias);
-    };
-    const fromRecord = (record) => {
-        const data = asRecord(record);
-        const alias = readOptionalString(data.alias);
-        const typeValue = data.type ?? baseTypeSource ?? baseType;
-        pushEntry(alias, buildAuthCandidate(typeValue, {
-            value: data.value ?? data.apiKey,
-            secretRef: data.secretRef,
-            tokenFile: data.tokenFile,
-            tokenUrl: data.tokenUrl ?? data.token_url,
-            deviceCodeUrl: data.deviceCodeUrl ?? data.device_code_url,
-            clientId: data.clientId ?? data.client_id,
-            clientSecret: data.clientSecret ?? data.client_secret,
-            authorizationUrl: data.authorizationUrl ??
-                data.authorization_url ??
-                data.authUrl,
-            userInfoUrl: data.userInfoUrl ?? data.user_info_url,
-            refreshUrl: data.refreshUrl ?? data.refresh_url,
-            scopes: data.scopes ?? data.scope
-        }));
-    };
-    if (Array.isArray(auth.entries)) {
-        for (const entry of auth.entries) {
-            fromRecord(entry);
-        }
-    }
-    if (Array.isArray(auth.keys)) {
-        for (const entry of auth.keys) {
-            fromRecord(entry);
-        }
-    }
-    else {
-        const keysObject = asRecord(auth.keys);
-        for (const [alias, entry] of Object.entries(keysObject)) {
-            if (entry && typeof entry === 'object') {
-                fromRecord({ alias, ...entry });
-            }
-            else if (typeof entry === 'string') {
-                pushEntry(alias, buildAuthCandidate(baseTypeSource, { value: entry }));
-            }
-        }
-    }
-    const apiKeyField = provider.apiKey ?? provider.apiKeys ?? auth.apiKey;
-    if (Array.isArray(apiKeyField)) {
-        for (const item of apiKeyField) {
-            if (typeof item === 'string' && item.trim()) {
-                pushEntry(undefined, buildAuthCandidate(baseTypeSource, { value: item.trim() }));
-            }
-            else if (item && typeof item === 'object') {
-                fromRecord(item);
-            }
-        }
-    }
-    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),
-            secretRef: readOptionalString(auth.secretRef),
-            tokenFile: readOptionalString(auth.tokenFile ?? auth.file),
-            tokenUrl: readOptionalString(auth.tokenUrl ?? auth.token_url),
-            deviceCodeUrl: readOptionalString(auth.deviceCodeUrl ?? auth.device_code_url),
-            clientId: readOptionalString(auth.clientId ?? auth.client_id),
-            clientSecret: readOptionalString(auth.clientSecret ?? auth.client_secret),
-            authorizationUrl: readOptionalString(auth?.authorizationUrl ?? auth?.authorization_url ?? auth?.authUrl),
-            userInfoUrl: readOptionalString(auth?.userInfoUrl ?? auth?.user_info_url),
-            refreshUrl: readOptionalString(auth?.refreshUrl ?? auth?.refresh_url),
-            scopes: normalizeScopeList(auth?.scopes ?? auth?.scope)
-        };
-        const fallbackHasData = Boolean(fallbackExtras.value ||
-            fallbackExtras.secretRef ||
-            fallbackExtras.tokenFile ||
-            fallbackExtras.tokenUrl ||
-            fallbackExtras.deviceCodeUrl ||
-            fallbackExtras.clientId ||
-            fallbackExtras.clientSecret ||
-            (fallbackExtras.scopes &&
-                Array.isArray(fallbackExtras.scopes) &&
-                fallbackExtras.scopes.length));
-        if (fallbackHasData) {
-            pushEntry(undefined, buildAuthCandidate(baseTypeSource, fallbackExtras));
-        }
-    }
-    if (!entries.length) {
-        throw new VirtualRouterError(`Provider ${providerId} is missing auth configuration`, VirtualRouterErrorCode.CONFIG_ERROR);
-    }
-    return entries;
-}
-function parseRouteEntry(entry, aliasIndex) {
-    const value = typeof entry === 'string' ? entry.trim() : '';
-    if (!value)
-        return null;
-    const firstDot = value.indexOf('.');
-    if (firstDot <= 0 || firstDot === value.length - 1)
-        return null;
-    const providerId = value.slice(0, firstDot);
-    const remainder = value.slice(firstDot + 1);
-    const aliases = aliasIndex.get(providerId);
-    if (aliases && aliases.length) {
-        const secondDot = remainder.indexOf('.');
-        if (secondDot > 0 && secondDot < remainder.length - 1) {
-            const aliasCandidate = remainder.slice(0, secondDot);
-            if (aliases.includes(aliasCandidate)) {
-                return {
-                    providerId,
-                    keyAlias: aliasCandidate,
-                    modelId: remainder.slice(secondDot + 1)
-                };
-            }
-        }
-    }
-    return { providerId, modelId: remainder };
-}
-function parseTargetKey(targetKey) {
-    const value = typeof targetKey === 'string' ? targetKey.trim() : '';
-    if (!value)
-        return null;
-    const firstDot = value.indexOf('.');
-    if (firstDot <= 0 || firstDot === value.length - 1)
-        return null;
-    const providerId = value.slice(0, firstDot);
-    const remainder = value.slice(firstDot + 1);
-    const secondDot = remainder.indexOf('.');
-    if (secondDot <= 0 || secondDot === remainder.length - 1)
-        return null;
-    return {
-        providerId,
-        keyAlias: remainder.slice(0, secondDot),
-        modelId: remainder.slice(secondDot + 1)
-    };
-}
-function detectProviderType(provider) {
-    const raw = (provider.providerType || provider.protocol || provider.type || '').toString().toLowerCase();
-    const id = (provider.providerId || provider.id || '').toString().toLowerCase();
-    const match = (value, keyword) => value.includes(keyword);
-    const source = `${raw}|${id}`;
-    const normalized = (src) => (src && src.trim() ? src.trim() : '');
-    const lexicon = normalized(source);
-    if (!lexicon)
-        return 'openai';
-    if (match(lexicon, 'anthropic') || match(lexicon, 'claude'))
-        return 'anthropic';
-    if (match(lexicon, 'responses'))
-        return 'responses';
-    if (match(lexicon, 'gemini'))
-        return 'gemini';
-    if (match(lexicon, 'iflow'))
-        return 'iflow';
-    if (match(lexicon, 'qwen'))
-        return 'qwen';
-    if (match(lexicon, 'glm'))
-        return 'glm';
-    if (match(lexicon, 'lmstudio'))
-        return 'lmstudio';
-    return raw || 'openai';
-}
-function mapOutboundProfile(providerType) {
-    const value = providerType.toLowerCase();
-    if (value === 'anthropic')
-        return 'anthropic-messages';
-    if (value === 'responses')
-        return 'openai-responses';
-    if (value === 'gemini')
-        return 'gemini-chat';
-    return 'openai-chat';
-}
-function collectAuthDefaults(auth) {
-    return {
-        secretRef: readOptionalString(auth.secretRef) ?? readOptionalString(auth?.file),
-        tokenFile: readOptionalString(auth.tokenFile) ?? readOptionalString(auth?.file),
-        tokenUrl: readOptionalString(auth.tokenUrl ?? auth.token_url),
-        deviceCodeUrl: readOptionalString(auth.deviceCodeUrl ?? auth.device_code_url),
-        clientId: readOptionalString(auth.clientId ?? auth.client_id),
-        clientSecret: readOptionalString(auth.clientSecret ?? auth.client_secret),
-        authorizationUrl: readOptionalString(auth?.authorizationUrl ?? auth?.authorization_url ?? auth?.authUrl),
-        userInfoUrl: readOptionalString(auth?.userInfoUrl ?? auth?.user_info_url),
-        refreshUrl: readOptionalString(auth?.refreshUrl ?? auth?.refresh_url),
-        scopes: normalizeScopeList(auth?.scopes ?? auth?.scope)
-    };
-}
-function readOptionalString(value) {
-    if (typeof value !== 'string') {
-        return undefined;
-    }
-    const trimmed = value.trim();
-    return trimmed ? trimmed : undefined;
-}
-function normalizeScopeList(value) {
-    if (Array.isArray(value)) {
-        const normalized = value
-            .map((item) => readOptionalString(item))
-            .filter((item) => typeof item === 'string');
-        return normalized.length ? normalized : undefined;
-    }
-    if (typeof value === 'string' && value.trim()) {
-        const normalized = value
-            .split(/[\,\s]+/)
-            .map((item) => item.trim())
-            .filter(Boolean);
-        return normalized.length ? normalized : undefined;
-    }
-    return undefined;
-}
-function mergeScopes(primary, fallback) {
-    if ((!primary || !primary.length) && (!fallback || !fallback.length)) {
-        return undefined;
-    }
-    const merged = new Set();
-    for (const scope of primary ?? []) {
-        if (scope.trim())
-            merged.add(scope.trim());
-    }
-    for (const scope of fallback ?? []) {
-        if (scope.trim())
-            merged.add(scope.trim());
-    }
-    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' };
-    }
-    const trimmed = value.trim();
-    if (!trimmed) {
-        return { type: 'apiKey' };
-    }
-    const lower = trimmed.toLowerCase();
-    if (lower === 'apikey' || lower === 'api-key') {
-        return { type: 'apiKey', raw: trimmed };
-    }
-    if (lower === 'oauth') {
-        return { type: 'oauth', raw: trimmed };
-    }
-    const match = lower.match(/^([a-z0-9._-]+)-oauth$/);
-    if (match) {
-        return { type: 'oauth', oauthProviderId: match[1], raw: trimmed };
-    }
-    if (lower.includes('oauth')) {
-        return { type: 'oauth', raw: trimmed };
-    }
-    return { type: 'apiKey', raw: trimmed };
-}
-function normalizeLoadBalancing(input) {
-    if (!input || typeof input !== 'object')
-        return undefined;
-    const record = input;
-    const strategyRaw = typeof record.strategy === 'string' ? record.strategy.trim().toLowerCase() : '';
-    if (!strategyRaw)
-        return undefined;
-    const strategy = strategyRaw === 'weighted' || strategyRaw === 'sticky' ? strategyRaw : 'round-robin';
-    const weightsRaw = asRecord(record.weights);
-    const weightsEntries = {};
-    for (const [key, value] of Object.entries(weightsRaw)) {
-        if (typeof value === 'number' && Number.isFinite(value)) {
-            weightsEntries[key] = value;
-        }
-    }
-    return Object.keys(weightsEntries).length
-        ? { 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;
-    const record = input;
-    const failureThreshold = typeof record.failureThreshold === 'number' ? record.failureThreshold : undefined;
-    const cooldownMs = typeof record.cooldownMs === 'number' ? record.cooldownMs : undefined;
-    const fatalCooldownMs = typeof record.fatalCooldownMs === 'number' ? record.fatalCooldownMs : undefined;
-    if (typeof failureThreshold !== 'number' || typeof cooldownMs !== 'number') {
-        return undefined;
-    }
-    return fatalCooldownMs !== undefined
-        ? { 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;
-    }
-    const entries = {};
-    for (const [key, value] of Object.entries(input)) {
-        if (typeof value === 'string') {
-            entries[key] = value;
-        }
-    }
-    return Object.keys(entries).length ? entries : undefined;
-}
-function asRecord(value) {
-    return (value && typeof value === 'object' ? value : {});
-}
-function normalizeAlias(candidate, existing) {
-    const base = candidate && candidate.trim() ? candidate.trim() : `key${existing.size + 1}`;
-    let alias = base;
-    let i = 1;
-    while (existing.has(alias)) {
-        alias = `${base}_${i}`;
-        i += 1;
-    }
-    return alias;
-}
-function pushUnique(list, value) {
-    if (!list.includes(value)) {
-        list.push(value);
-    }
-}
-function buildRuntimeKey(providerId, keyAlias) {
-    return `${providerId}.${keyAlias}`;
-}