@jsonstudio/llms 0.6.1892 → 0.6.2172

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

@@ -0,0 +1,293 @@
+import { VirtualRouterError, VirtualRouterErrorCode } from '../types.js';
+import { readOptionalString } from './utils.js';
+export 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;
+}
+export function expandRoutingTable(routingSource, aliasIndex, modelIndex) {
+    const routing = {};
+    const targetKeys = new Set();
+    for (const [routeName, pools] of Object.entries(routingSource)) {
+        const expandedPools = [];
+        for (const pool of pools) {
+            const expandedTargets = [];
+            let orderCounter = 0;
+            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 modelInfo = modelIndex.get(parsed.providerId);
+                if (modelInfo?.declared) {
+                    if (!parsed.modelId) {
+                        throw new VirtualRouterError(`Route "${routeName}" references empty model id for provider "${parsed.providerId}"`, VirtualRouterErrorCode.CONFIG_ERROR);
+                    }
+                    const knownModels = modelInfo.models ?? [];
+                    if (!knownModels.length) {
+                        throw new VirtualRouterError(`Route "${routeName}" references provider "${parsed.providerId}" but provider declares no models`, VirtualRouterErrorCode.CONFIG_ERROR);
+                    }
+                    if (!knownModels.includes(parsed.modelId)) {
+                        throw new VirtualRouterError(`Route "${routeName}" references unknown model "${parsed.modelId}" for 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}`;
+                    const existing = expandedTargets.find((candidate) => candidate.key === targetKey);
+                    if (existing) {
+                        if (parsed.priority > existing.priority) {
+                            existing.priority = parsed.priority;
+                        }
+                        continue;
+                    }
+                    expandedTargets.push({ key: targetKey, priority: parsed.priority, order: orderCounter });
+                    orderCounter += 1;
+                    targetKeys.add(targetKey);
+                }
+            }
+            if (expandedTargets.length) {
+                const sortedTargets = pool.mode === 'priority'
+                    ? [...expandedTargets]
+                        .sort((a, b) => {
+                        if (a.priority !== b.priority) {
+                            return b.priority - a.priority;
+                        }
+                        return a.order - b.order;
+                    })
+                        .map((candidate) => candidate.key)
+                    : expandedTargets.map((candidate) => candidate.key);
+                expandedPools.push({
+                    id: pool.id,
+                    priority: pool.priority,
+                    backup: pool.backup,
+                    targets: sortedTargets,
+                    ...(pool.mode ? { mode: pool.mode } : {}),
+                    ...(pool.force ? { force: true } : {})
+                });
+            }
+        }
+        routing[routeName] = expandedPools;
+    }
+    return { routing, targetKeys };
+}
+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 mode = normalizeRoutePoolMode(record.mode ?? record.strategy ?? record.routingMode);
+    const force = record.force === true ||
+        (typeof record.force === 'string' && record.force.trim().toLowerCase() === 'true');
+    return targets.length
+        ? {
+            id,
+            priority,
+            backup,
+            targets,
+            ...(mode ? { mode } : {}),
+            ...(force ? { force: true } : {})
+        }
+        : null;
+}
+function normalizeRoutePoolMode(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (!normalized) {
+        return undefined;
+    }
+    if (normalized === 'priority') {
+        return 'priority';
+    }
+    if (normalized === 'round-robin' ||
+        normalized === 'round_robin' ||
+        normalized === 'roundrobin' ||
+        normalized === 'rr') {
+        return 'round-robin';
+    }
+    return undefined;
+}
+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 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)) {
+                const parsed = splitModelPriority(remainder.slice(secondDot + 1));
+                return {
+                    providerId,
+                    keyAlias: aliasCandidate,
+                    modelId: parsed.modelId,
+                    priority: parsed.priority
+                };
+            }
+        }
+    }
+    const parsed = splitModelPriority(remainder);
+    return { providerId, modelId: parsed.modelId, priority: parsed.priority };
+}
+function splitModelPriority(raw) {
+    const value = typeof raw === 'string' ? raw.trim() : '';
+    if (!value) {
+        return { modelId: value, priority: 100 };
+    }
+    const match = value.match(/^(.*):(\d+)$/);
+    if (!match) {
+        return { modelId: value, priority: 100 };
+    }
+    const modelId = (match[1] ?? '').trim();
+    const priorityRaw = (match[2] ?? '').trim();
+    const parsed = Number(priorityRaw);
+    if (!modelId) {
+        return { modelId: value, priority: 100 };
+    }
+    if (!Number.isFinite(parsed)) {
+        return { modelId, priority: 100 };
+    }
+    return { modelId, priority: parsed };
+}
+export 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)
+    };
+}
+export function buildRuntimeKey(providerId, keyAlias) {
+    return `${providerId}.${keyAlias}`;
+}

package/dist/router/virtual-router/bootstrap/streaming-helpers.d.ts

@@ -0,0 +1,12 @@
+import { type StreamingPreference } from '../types.js';
+/**
+ * Normalize model-level streaming preferences from provider config.
+ */
+export declare function normalizeModelStreaming(provider: Record<string, unknown>): Record<string, StreamingPreference> | undefined;
+/**
+ * Normalize model-level context token limits.
+ */
+export declare function normalizeModelContextTokens(provider: Record<string, unknown>): {
+    modelContextTokens?: Record<string, number>;
+    defaultContextTokens?: number;
+};

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

@@ -0,0 +1,128 @@
+import { asRecord } from './utils.js';
+/**
+ * Normalize model-level streaming preferences from provider config.
+ */
+export 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;
+}
+/**
+ * Resolve streaming preference from model config.
+ */
+function resolveStreamingPreference(model) {
+    return (coerceStreamingPreference(model.streaming) ??
+        coerceStreamingPreference(model.stream) ??
+        coerceStreamingPreference(model.supportsStreaming));
+}
+/**
+ * Coerce various value types to StreamingPreference.
+ */
+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;
+}
+/**
+ * Normalize model-level context token limits.
+ */
+export 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
+    };
+}
+/**
+ * Read context tokens from various field names.
+ */
+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;
+}
+/**
+ * Normalize positive integer value.
+ */
+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;
+}

package/dist/router/virtual-router/bootstrap/utils.d.ts

@@ -0,0 +1,5 @@
+export declare function asRecord<T extends Record<string, unknown>>(value: unknown): T;
+export declare function readOptionalString(value: unknown): string | undefined;
+export declare function normalizePositiveInteger(value: unknown): number | undefined;
+export declare function normalizeAlias(candidate: string | undefined, existing: Set<string>): string;
+export declare function pushUnique<T>(list: T[], value: T): void;

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

@@ -0,0 +1,41 @@
+export function asRecord(value) {
+    return (value && typeof value === 'object' ? value : {});
+}
+export function readOptionalString(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed ? trimmed : undefined;
+}
+export 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;
+}
+export 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;
+}
+export function pushUnique(list, value) {
+    if (!list.includes(value)) {
+        list.push(value);
+    }
+}

package/dist/router/virtual-router/bootstrap/web-search-config.d.ts

@@ -0,0 +1,4 @@
+import { type VirtualRouterWebSearchConfig } from '../types.js';
+import type { NormalizedRoutePoolConfig } from './routing-config.js';
+export declare function validateWebSearchRouting(webSearch: VirtualRouterWebSearchConfig | undefined, routingSource: Record<string, NormalizedRoutePoolConfig[]>): void;
+export declare function normalizeWebSearch(input: unknown, routingSource: Record<string, NormalizedRoutePoolConfig[]>): VirtualRouterWebSearchConfig | undefined;

package/dist/router/virtual-router/bootstrap/web-search-config.js

@@ -0,0 +1,131 @@
+import { VirtualRouterError, VirtualRouterErrorCode } from '../types.js';
+export function validateWebSearchRouting(webSearch, routingSource) {
+    if (!webSearch) {
+        return;
+    }
+    const routePools = routingSource.web_search;
+    if (!Array.isArray(routePools) || !routePools.length) {
+        throw new VirtualRouterError('Virtual Router webSearch.engines configured but routing.web_search route is missing or empty', VirtualRouterErrorCode.CONFIG_ERROR);
+    }
+    const targets = new Set(collectWebSearchRouteTargets(routingSource));
+    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);
+        }
+    }
+}
+export function normalizeWebSearch(input, routingSource) {
+    if (!input || typeof input !== 'object') {
+        return undefined;
+    }
+    const record = input;
+    const enginesNode = Array.isArray(record.engines) ? record.engines : [];
+    const engines = [];
+    const webSearchRouteTargets = collectWebSearchRouteTargets(routingSource);
+    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 resolvedProviderKey = resolveWebSearchEngineProviderKey(providerKey, webSearchRouteTargets) ?? providerKey;
+        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);
+        if (engines.some((engine) => engine.id === id)) {
+            continue;
+        }
+        engines.push({
+            id,
+            providerKey: resolvedProviderKey,
+            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 ?? [];
+        if (Array.isArray(webSearchPools) && webSearchPools.some((pool) => pool.force)) {
+            force = true;
+        }
+    }
+    return {
+        engines,
+        injectPolicy: injectPolicy ?? 'selective',
+        ...(force ? { force } : {})
+    };
+}
+function collectWebSearchRouteTargets(routingSource) {
+    const routePools = routingSource.web_search;
+    if (!Array.isArray(routePools) || !routePools.length) {
+        return [];
+    }
+    const seen = new Set();
+    const targets = [];
+    for (const pool of routePools) {
+        if (!pool || !Array.isArray(pool.targets)) {
+            continue;
+        }
+        for (const target of pool.targets) {
+            if (typeof target !== 'string') {
+                continue;
+            }
+            const normalized = target.trim();
+            if (!normalized || seen.has(normalized)) {
+                continue;
+            }
+            seen.add(normalized);
+            targets.push(normalized);
+        }
+    }
+    return targets;
+}
+function resolveWebSearchEngineProviderKey(providerKey, routeTargets) {
+    const input = providerKey.trim();
+    if (!input) {
+        return undefined;
+    }
+    if (routeTargets.includes(input)) {
+        return input;
+    }
+    const prefixMatches = routeTargets.filter((target) => target.startsWith(`${input}.`));
+    if (prefixMatches.length > 0) {
+        return prefixMatches[0];
+    }
+    const firstDot = input.indexOf('.');
+    if (firstDot > 0 && firstDot < input.length - 1) {
+        const providerId = input.slice(0, firstDot);
+        const modelSuffix = input.slice(firstDot + 1);
+        const suffixMatches = routeTargets.filter((target) => target.startsWith(`${providerId}.`) && target.endsWith(`.${modelSuffix}`));
+        if (suffixMatches.length > 0) {
+            return suffixMatches[0];
+        }
+    }
+    return undefined;
+}

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

@@ -1,6 +1,2 @@
 import { type VirtualRouterBootstrapInput, type VirtualRouterBootstrapResult } from './types.js';
-/**
- * 将用户提供的 Virtual Router 配置（或包含 virtualrouter 字段的整体配置）
- * 规范化为 VirtualRouterConfig，供 HubPipeline / VirtualRouterEngine 直接使用。
- */
 export declare function bootstrapVirtualRouterConfig(input: VirtualRouterBootstrapInput): VirtualRouterBootstrapResult;