@jsonstudio/llms 0.4.2

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

@@ -0,0 +1,620 @@
+import { VirtualRouterError, VirtualRouterErrorCode } from './types.js';
+const DEFAULT_CLASSIFIER = {
+    longContextThresholdTokens: 60000,
+    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 };
+/**
+ * 将用户提供的 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 { 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 config = {
+        routing,
+        providers: providerProfiles,
+        classifier,
+        loadBalancing,
+        health
+    };
+    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);
+    return { providers, routing, classifier, loadBalancing, health };
+}
+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
+            };
+            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
+            };
+        }
+    }
+    return { runtimeEntries, aliasIndex };
+}
+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 alias of aliases) {
+                const runtimeKey = buildRuntimeKey(parsed.providerId, alias);
+                const targetKey = `${runtimeKey}.${parsed.modelId}`;
+                pushUnique(expanded, targetKey);
+                targetKeys.add(targetKey);
+            }
+        }
+        routing[routeName] = expanded;
+    }
+    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);
+        }
+        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'
+        };
+        targetRuntime[targetKey] = {
+            ...runtime,
+            modelId: parsed.modelId
+        };
+    }
+    return { profiles, targetRuntime };
+}
+function normalizeRouting(source) {
+    const routing = {};
+    for (const [routeName, entries] of Object.entries(source)) {
+        if (!Array.isArray(entries))
+            continue;
+        const normalized = entries
+            .map((entry) => (typeof entry === 'string' ? entry.trim() : ''))
+            .filter(Boolean);
+        routing[routeName] = Array.from(new Set(normalized));
+    }
+    return routing;
+}
+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(provider);
+    const processMode = normalizeProcessMode(provider.process);
+    return {
+        providerId,
+        providerType,
+        endpoint,
+        headers,
+        outboundProfile: mapOutboundProfile(providerType),
+        compatibilityProfile,
+        processMode
+    };
+}
+function resolveCompatibilityProfile(provider) {
+    const compat = provider.compat;
+    if (typeof compat === 'string' && compat.trim().length > 0) {
+        return compat.trim();
+    }
+    return 'default';
+}
+function normalizeProcessMode(value) {
+    if (typeof value !== 'string') {
+        return 'chat';
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'passthrough') {
+        return 'passthrough';
+    }
+    return 'chat';
+}
+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() }));
+    }
+    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;
+}
+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 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 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}`;
+}

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

@@ -0,0 +1,10 @@
+import type { ClassificationResult, RoutingFeatures, VirtualRouterClassifierConfig } from './types.js';
+export declare class RoutingClassifier {
+    private readonly config;
+    constructor(config: VirtualRouterClassifierConfig);
+    classify(features: RoutingFeatures): ClassificationResult;
+    private buildResult;
+    private ensureDefaultCandidate;
+    private orderRoutes;
+    private routeWeight;
+}