@jsonstudio/rcc 0.90.367 → 0.90.701

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

@@ -1,156 +0,0 @@
-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 rawExecutionMode = typeof node.executionMode === 'string'
-            ? node.executionMode.trim().toLowerCase()
-            : typeof node.mode === 'string'
-                ? node.mode.trim().toLowerCase()
-                : '';
-        const executionMode = rawExecutionMode === 'direct' ? 'direct' : 'servertool';
-        const rawDirectActivation = typeof node.directActivation === 'string'
-            ? node.directActivation.trim().toLowerCase()
-            : typeof node.activation === 'string'
-                ? node.activation.trim().toLowerCase()
-                : '';
-        const directActivation = rawDirectActivation === 'builtin'
-            ? 'builtin'
-            : rawDirectActivation === 'route'
-                ? 'route'
-                : executionMode === 'direct'
-                    ? 'route'
-                    : undefined;
-        const modelId = typeof node.modelId === 'string' && node.modelId.trim() ? node.modelId.trim() : undefined;
-        const maxUsesRaw = typeof node.maxUses === 'number' ? node.maxUses : Number(node.maxUses);
-        const maxUses = Number.isFinite(maxUsesRaw) && maxUsesRaw > 0 ? Math.floor(maxUsesRaw) : undefined;
-        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,
-            executionMode,
-            ...(directActivation ? { directActivation } : {}),
-            ...(modelId ? { modelId } : {}),
-            ...(maxUses ? { maxUses } : {}),
-            ...(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/vendor/llmswitch-core/dist/router/virtual-router/bootstrap.d.ts

@@ -1,2 +0,0 @@
-import { type VirtualRouterBootstrapInput, type VirtualRouterBootstrapResult } from './types.js';
-export declare function bootstrapVirtualRouterConfig(input: VirtualRouterBootstrapInput): VirtualRouterBootstrapResult;

package/vendor/llmswitch-core/dist/router/virtual-router/bootstrap.js

@@ -1,329 +0,0 @@
-import { VirtualRouterError, VirtualRouterErrorCode } from './types.js';
-import { DEFAULT_CLASSIFIER, DEFAULT_CONTEXT_ROUTING, DEFAULT_HEALTH, DEFAULT_LOAD_BALANCING } from './bootstrap/config-defaults.js';
-import { asRecord } from './bootstrap/utils.js';
-import { normalizeClock, normalizeContextRouting, normalizeExecCommandGuard } from './bootstrap/config-normalizers.js';
-import { normalizeHealth, buildProviderProfiles } from './bootstrap/profile-builder.js';
-import { normalizeRouting, expandRoutingTable, buildRuntimeKey } from './bootstrap/routing-config.js';
-import { normalizeProvider } from './bootstrap/provider-normalization.js';
-import { extractProviderAuthEntries } from './bootstrap/auth-utils.js';
-import { normalizeWebSearch, validateWebSearchRouting } from './bootstrap/web-search-config.js';
-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);
-    const webSearch = normalizeWebSearch(section.webSearch, routingSource);
-    validateWebSearchRouting(webSearch, routingSource);
-    const execCommandGuard = normalizeExecCommandGuard(section.execCommandGuard);
-    const clock = normalizeClock(section.clock);
-    const { runtimeEntries, aliasIndex, modelIndex } = buildProviderRuntimeEntries(providersSource);
-    const { routing, targetKeys } = expandRoutingTable(routingSource, aliasIndex, modelIndex);
-    const expandedTargetKeys = new Set(targetKeys);
-    for (const [providerId, aliases] of aliasIndex.entries()) {
-        const models = modelIndex.get(providerId)?.models ?? [];
-        if (!models.length || !aliases.length) {
-            continue;
-        }
-        for (const alias of aliases) {
-            const runtimeKey = buildRuntimeKey(providerId, alias);
-            for (const modelId of models) {
-                if (modelId && typeof modelId === 'string') {
-                    expandedTargetKeys.add(`${runtimeKey}.${modelId}`);
-                }
-            }
-        }
-    }
-    const { profiles: providerProfiles, targetRuntime } = buildProviderProfiles(expandedTargetKeys, 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 } : {}),
-        ...(execCommandGuard ? { execCommandGuard } : {}),
-        ...(clock ? { clock } : {})
-    };
-    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;
-    const execCommandGuard = section.execCommandGuard ?? root.execCommandGuard;
-    const clock = section.clock ?? root.clock;
-    return { providers, routing, classifier, loadBalancing, health, contextRouting, webSearch, execCommandGuard, clock };
-}
-function buildProviderRuntimeEntries(providers) {
-    const runtimeEntries = {};
-    const aliasIndex = new Map();
-    const modelIndex = new Map();
-    for (const [providerId, providerRaw] of Object.entries(providers)) {
-        const normalizedProvider = normalizeProvider(providerId, providerRaw);
-        modelIndex.set(providerId, collectProviderModels(providerRaw, normalizedProvider));
-        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.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,
-                ...(normalizedProvider.enabled !== undefined ? { enabled: normalizedProvider.enabled } : {}),
-                outboundProfile: normalizedProvider.outboundProfile,
-                compatibilityProfile: normalizedProvider.compatibilityProfile,
-                processMode: normalizedProvider.processMode,
-                responsesConfig: normalizedProvider.responsesConfig,
-                streaming: normalizedProvider.streaming,
-                modelStreaming: normalizedProvider.modelStreaming,
-                modelOutputTokens: normalizedProvider.modelOutputTokens,
-                defaultOutputTokens: normalizedProvider.defaultOutputTokens,
-                modelContextTokens: normalizedProvider.modelContextTokens,
-                defaultContextTokens: normalizedProvider.defaultContextTokens,
-                ...(normalizedProvider.deepseek ? { deepseek: normalizedProvider.deepseek } : {}),
-                ...(normalizedProvider.serverToolsDisabled ? { serverToolsDisabled: true } : {}),
-                ...(normalizedProvider.modelCapabilities ? { modelCapabilities: normalizedProvider.modelCapabilities } : {})
-            };
-        }
-    }
-    return { runtimeEntries, aliasIndex, modelIndex };
-}
-function collectProviderModels(providerRaw, _normalizedProvider) {
-    const rawModelsNode = providerRaw.models;
-    const modelsDeclared = rawModelsNode !== undefined;
-    const collected = new Set();
-    if (Array.isArray(rawModelsNode)) {
-        for (const model of rawModelsNode) {
-            if (!model || typeof model !== 'object') {
-                continue;
-            }
-            const modelObj = model;
-            const modelId = typeof modelObj.id === 'string' ? modelObj.id.trim() : '';
-            if (modelId) {
-                collected.add(modelId);
-            }
-            const aliasesNode = Array.isArray(modelObj.aliases)
-                ? modelObj.aliases
-                : [];
-            for (const alias of aliasesNode) {
-                if (typeof alias !== 'string') {
-                    continue;
-                }
-                const normalizedAlias = alias.trim();
-                if (normalizedAlias) {
-                    collected.add(normalizedAlias);
-                }
-            }
-        }
-    }
-    else {
-        const modelsNode = asRecord(rawModelsNode);
-        for (const [modelName, modelConfigRaw] of Object.entries(modelsNode)) {
-            const normalizedModelName = typeof modelName === 'string' ? modelName.trim() : '';
-            if (normalizedModelName) {
-                collected.add(normalizedModelName);
-            }
-            const modelConfig = asRecord(modelConfigRaw);
-            const aliasesNode = Array.isArray(modelConfig.aliases)
-                ? modelConfig.aliases
-                : [];
-            for (const alias of aliasesNode) {
-                if (typeof alias !== 'string') {
-                    continue;
-                }
-                const normalizedAlias = alias.trim();
-                if (normalizedAlias) {
-                    collected.add(normalizedAlias);
-                }
-            }
-        }
-    }
-    return { declared: modelsDeclared, models: Array.from(collected) };
-}
-function normalizeClassifier(input) {
-    const normalized = asRecord(input);
-    return {
-        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)
-    };
-}
-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 normalizeLoadBalancing(input) {
-    if (!input || typeof input !== 'object')
-        return undefined;
-    const record = input;
-    const strategyRaw = typeof record.strategy === 'string' ? record.strategy.trim().toLowerCase() : '';
-    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;
-        }
-    }
-    const healthWeightedRaw = asRecord(record.healthWeighted);
-    const healthWeighted = Object.keys(healthWeightedRaw).length > 0
-        ? {
-            ...(typeof healthWeightedRaw.enabled === 'boolean' ? { enabled: healthWeightedRaw.enabled } : {}),
-            ...(typeof healthWeightedRaw.recoverToBestOnRetry === 'boolean'
-                ? { recoverToBestOnRetry: healthWeightedRaw.recoverToBestOnRetry }
-                : {}),
-            ...(typeof healthWeightedRaw.baseWeight === 'number' && Number.isFinite(healthWeightedRaw.baseWeight)
-                ? { baseWeight: healthWeightedRaw.baseWeight }
-                : {}),
-            ...(typeof healthWeightedRaw.minMultiplier === 'number' && Number.isFinite(healthWeightedRaw.minMultiplier)
-                ? { minMultiplier: healthWeightedRaw.minMultiplier }
-                : {}),
-            ...(typeof healthWeightedRaw.beta === 'number' && Number.isFinite(healthWeightedRaw.beta)
-                ? { beta: healthWeightedRaw.beta }
-                : {}),
-            ...(typeof healthWeightedRaw.halfLifeMs === 'number' && Number.isFinite(healthWeightedRaw.halfLifeMs)
-                ? { halfLifeMs: healthWeightedRaw.halfLifeMs }
-                : {})
-        }
-        : undefined;
-    const contextWeightedRaw = asRecord(record.contextWeighted);
-    const contextWeighted = Object.keys(contextWeightedRaw).length > 0
-        ? {
-            ...(typeof contextWeightedRaw.enabled === 'boolean' ? { enabled: contextWeightedRaw.enabled } : {}),
-            ...(typeof contextWeightedRaw.clientCapTokens === 'number' && Number.isFinite(contextWeightedRaw.clientCapTokens)
-                ? { clientCapTokens: contextWeightedRaw.clientCapTokens }
-                : {}),
-            ...(typeof contextWeightedRaw.gamma === 'number' && Number.isFinite(contextWeightedRaw.gamma)
-                ? { gamma: contextWeightedRaw.gamma }
-                : {}),
-            ...(typeof contextWeightedRaw.maxMultiplier === 'number' && Number.isFinite(contextWeightedRaw.maxMultiplier)
-                ? { maxMultiplier: contextWeightedRaw.maxMultiplier }
-                : {})
-        }
-        : undefined;
-    const aliasSelection = normalizeAliasSelection(record.aliasSelection);
-    const hasNonStrategyConfig = Object.keys(weightsEntries).length > 0 ||
-        Boolean(healthWeighted) ||
-        Boolean(contextWeighted) ||
-        Boolean(aliasSelection);
-    if (!strategyRaw && !hasNonStrategyConfig) {
-        return undefined;
-    }
-    const strategy = strategyRaw === 'weighted' || strategyRaw === 'sticky' ? strategyRaw : 'round-robin';
-    return {
-        strategy,
-        ...(Object.keys(weightsEntries).length ? { weights: weightsEntries } : {}),
-        ...(aliasSelection ? { aliasSelection } : {}),
-        ...(healthWeighted ? { healthWeighted } : {}),
-        ...(contextWeighted ? { contextWeighted } : {})
-    };
-}
-function normalizeAliasSelection(raw) {
-    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
-        return undefined;
-    }
-    const record = raw;
-    const enabled = typeof record.enabled === 'boolean' ? record.enabled : undefined;
-    const defaultStrategy = coerceAliasSelectionStrategy(record.defaultStrategy);
-    const sessionLeaseCooldownMs = typeof record.sessionLeaseCooldownMs === 'number' && Number.isFinite(record.sessionLeaseCooldownMs)
-        ? Math.max(0, Math.floor(record.sessionLeaseCooldownMs))
-        : typeof record.sessionLease_cooldown_ms === 'number' &&
-            Number.isFinite(record.sessionLease_cooldown_ms)
-            ? Math.max(0, Math.floor(record.sessionLease_cooldown_ms))
-            : undefined;
-    const antigravitySessionBindingRaw = typeof record.antigravitySessionBinding === 'string'
-        ? record.antigravitySessionBinding.trim().toLowerCase()
-        : typeof record.antigravity_session_binding === 'string'
-            ? String(record.antigravity_session_binding).trim().toLowerCase()
-            : '';
-    const antigravitySessionBinding = antigravitySessionBindingRaw === 'strict'
-        ? 'strict'
-        : antigravitySessionBindingRaw === 'lease'
-            ? 'lease'
-            : undefined;
-    const providersRaw = asRecord(record.providers);
-    const providers = {};
-    for (const [providerId, value] of Object.entries(providersRaw)) {
-        const strategy = coerceAliasSelectionStrategy(value);
-        if (strategy) {
-            providers[providerId] = strategy;
-        }
-    }
-    const out = {
-        ...(enabled !== undefined ? { enabled } : {}),
-        ...(defaultStrategy ? { defaultStrategy } : {}),
-        ...(sessionLeaseCooldownMs !== undefined ? { sessionLeaseCooldownMs } : {}),
-        ...(antigravitySessionBinding ? { antigravitySessionBinding } : {}),
-        ...(Object.keys(providers).length ? { providers } : {})
-    };
-    return Object.keys(out).length ? out : undefined;
-}
-function coerceAliasSelectionStrategy(value) {
-    if (typeof value !== 'string') {
-        return undefined;
-    }
-    const normalized = value.trim().toLowerCase();
-    if (!normalized) {
-        return undefined;
-    }
-    if (normalized === 'none')
-        return 'none';
-    if (normalized === 'sticky-queue' || normalized === 'sticky_queue' || normalized === 'stickyqueue') {
-        return 'sticky-queue';
-    }
-    return undefined;
-}

package/vendor/llmswitch-core/dist/router/virtual-router/classifier.d.ts

@@ -1,10 +0,0 @@
-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;
-}