@jsonstudio/rcc 0.90.352 → 0.90.367

package/vendor/llmswitch-core/dist/quota/quota-state.js

@@ -0,0 +1,191 @@
+const COOLDOWN_SCHEDULE_429_MS = [3_000, 10_000, 31_000, 61_000];
+const COOLDOWN_SCHEDULE_FATAL_MS = [3_000, 10_000, 31_000, 61_000];
+const COOLDOWN_SCHEDULE_DEFAULT_MS = [3_000, 10_000, 31_000, 61_000];
+const COOLDOWN_SCHEDULE_TRANSIENT_KEEP_POOL_MS = [3_000, 5_000, 10_000, 31_000];
+const ERROR_CHAIN_WINDOW_MS = 10 * 60_000;
+const NETWORK_ERROR_CODES = [
+    'ECONNRESET',
+    'ECONNREFUSED',
+    'ETIMEDOUT',
+    'EAI_AGAIN',
+    'UPSTREAM_HEADERS_TIMEOUT',
+    'UPSTREAM_STREAM_TIMEOUT',
+    'UPSTREAM_STREAM_IDLE_TIMEOUT',
+    'UPSTREAM_STREAM_ABORTED'
+];
+export function createInitialQuotaState(providerKey, staticConfig, nowMs = Date.now()) {
+    const priorityTier = staticConfig && typeof staticConfig.priorityTier === 'number'
+        ? staticConfig.priorityTier
+        : 100;
+    const authType = staticConfig && typeof staticConfig.authType === 'string' && staticConfig.authType.trim()
+        ? staticConfig.authType.trim()
+        : 'unknown';
+    return {
+        providerKey,
+        inPool: true,
+        reason: 'ok',
+        authType,
+        authIssue: null,
+        priorityTier,
+        cooldownUntil: null,
+        blacklistUntil: null,
+        lastErrorSeries: null,
+        lastErrorCode: null,
+        lastErrorAtMs: null,
+        consecutiveErrorCount: 0
+    };
+}
+export function normalizeErrorSeries(event) {
+    if (event.fatal) {
+        return 'EFATAL';
+    }
+    const status = typeof event.httpStatus === 'number' ? event.httpStatus : null;
+    const rawCode = String(event.code || '').toUpperCase();
+    if (status === 429 || rawCode.includes('429') || rawCode.includes('RATE') || rawCode.includes('QUOTA')) {
+        return 'E429';
+    }
+    if (status && status >= 500) {
+        return 'E5XX';
+    }
+    if (rawCode.includes('TIMEOUT') || NETWORK_ERROR_CODES.some((code) => rawCode.includes(code))) {
+        return 'ENET';
+    }
+    if (rawCode.includes('AUTH') || rawCode.includes('UNAUTHORIZED') || rawCode.includes('CONFIG') || rawCode.includes('FATAL')) {
+        return 'EFATAL';
+    }
+    return 'EOTHER';
+}
+function normalizeErrorKey(event) {
+    const rawCode = String(event.code || '').trim().toUpperCase();
+    const status = typeof event.httpStatus === 'number' ? event.httpStatus : null;
+    const isGenericCode = rawCode === '' ||
+        rawCode === 'ERR_PROVIDER_FAILURE' ||
+        rawCode === 'ERR_PIPELINE_FAILURE' ||
+        rawCode === 'ERR_COMPATIBILITY' ||
+        rawCode === 'EXTERNAL_ERROR' ||
+        rawCode === 'INTERNAL_ERROR' ||
+        rawCode === 'TOOL_ERROR';
+    if (!isGenericCode) {
+        return rawCode;
+    }
+    if (status && Number.isFinite(status)) {
+        return `HTTP_${Math.floor(status)}`;
+    }
+    return rawCode || 'ERR_UNKNOWN';
+}
+function computeCooldownMsBySeries(series, consecutive) {
+    if (consecutive <= 0) {
+        return null;
+    }
+    const schedule = series === 'E429'
+        ? COOLDOWN_SCHEDULE_429_MS
+        : series === 'EFATAL'
+            ? COOLDOWN_SCHEDULE_FATAL_MS
+            : COOLDOWN_SCHEDULE_DEFAULT_MS;
+    const idx = Math.min(consecutive - 1, schedule.length - 1);
+    return schedule[idx] ?? null;
+}
+function shouldKeepProviderInPoolDuringCooldown(series, consecutive) {
+    if (consecutive <= 0) {
+        return false;
+    }
+    return (series === 'ENET' || series === 'E5XX' || series === 'EOTHER') && consecutive <= 2;
+}
+function computeTransientKeepPoolCooldownMs(series, consecutive) {
+    if (!shouldKeepProviderInPoolDuringCooldown(series, consecutive)) {
+        return null;
+    }
+    const idx = Math.min(consecutive - 1, COOLDOWN_SCHEDULE_TRANSIENT_KEEP_POOL_MS.length - 1);
+    return COOLDOWN_SCHEDULE_TRANSIENT_KEEP_POOL_MS[idx] ?? null;
+}
+export function tickQuotaStateTime(state, nowMs) {
+    let next = state;
+    if (typeof next.cooldownUntil === 'number' && next.cooldownUntil <= nowMs) {
+        next = { ...next, cooldownUntil: null, cooldownKeepsPool: undefined };
+    }
+    if (typeof next.blacklistUntil === 'number' && next.blacklistUntil <= nowMs) {
+        next = { ...next, blacklistUntil: null };
+    }
+    if (next.authIssue) {
+        if (next.inPool !== false || next.reason !== 'authVerify') {
+            next = { ...next, inPool: false, reason: 'authVerify' };
+        }
+        return next;
+    }
+    const inCooldown = typeof next.cooldownUntil === 'number' && next.cooldownUntil > nowMs;
+    const inBlacklist = typeof next.blacklistUntil === 'number' && next.blacklistUntil > nowMs;
+    if (inBlacklist) {
+        if (next.inPool !== false || next.reason !== 'blacklist') {
+            next = { ...next, inPool: false, reason: 'blacklist' };
+        }
+        return next;
+    }
+    if (inCooldown) {
+        const keepInPool = next.cooldownKeepsPool === true;
+        if (next.inPool !== keepInPool || next.reason !== 'cooldown') {
+            next = { ...next, inPool: keepInPool, reason: 'cooldown' };
+        }
+        return next;
+    }
+    // TTLs expired: only auto-reset "cooldown/blacklist" back to ok.
+    if (next.reason === 'cooldown' || next.reason === 'blacklist') {
+        next = { ...next, inPool: true, reason: 'ok', cooldownKeepsPool: undefined };
+    }
+    return next;
+}
+export function applyErrorEvent(state, event, nowMs = event.timestampMs ?? Date.now()) {
+    // Manual/operator blacklist is rigid: automated error events must not override it.
+    if (state.blacklistUntil !== null && nowMs < state.blacklistUntil) {
+        return state;
+    }
+    const series = normalizeErrorSeries(event);
+    const errorKey = normalizeErrorKey(event);
+    const lastAt = typeof state.lastErrorAtMs === 'number' && Number.isFinite(state.lastErrorAtMs)
+        ? state.lastErrorAtMs
+        : null;
+    const withinChainWindow = typeof lastAt === 'number' &&
+        nowMs - lastAt >= 0 &&
+        nowMs - lastAt <= ERROR_CHAIN_WINDOW_MS;
+    const sameErrorKey = withinChainWindow && state.lastErrorCode === errorKey;
+    const schedule = series === 'E429'
+        ? COOLDOWN_SCHEDULE_429_MS
+        : series === 'EFATAL'
+            ? COOLDOWN_SCHEDULE_FATAL_MS
+            : COOLDOWN_SCHEDULE_DEFAULT_MS;
+    const rawNextCount = sameErrorKey ? state.consecutiveErrorCount + 1 : 1;
+    const nextCount = rawNextCount > schedule.length ? 1 : rawNextCount;
+    const cooldownMs = computeTransientKeepPoolCooldownMs(series, nextCount) ?? computeCooldownMsBySeries(series, nextCount);
+    const nextUntil = cooldownMs ? nowMs + cooldownMs : null;
+    const existingUntil = typeof state.cooldownUntil === 'number' ? state.cooldownUntil : null;
+    const cooldownUntil = typeof nextUntil === 'number' && Number.isFinite(nextUntil)
+        ? typeof existingUntil === 'number' && existingUntil > nextUntil
+            ? existingUntil
+            : nextUntil
+        : existingUntil;
+    const inCooldown = typeof cooldownUntil === 'number' && cooldownUntil > nowMs;
+    const inBlacklist = typeof state.blacklistUntil === 'number' && state.blacklistUntil > nowMs;
+    const cooldownKeepsPool = shouldKeepProviderInPoolDuringCooldown(series, nextCount);
+    const inPool = !inBlacklist && (!inCooldown || cooldownKeepsPool);
+    return {
+        ...state,
+        inPool,
+        reason: inBlacklist ? 'blacklist' : inCooldown ? 'cooldown' : 'ok',
+        cooldownUntil,
+        cooldownKeepsPool: inCooldown ? cooldownKeepsPool : undefined,
+        lastErrorSeries: series,
+        lastErrorCode: errorKey,
+        lastErrorAtMs: nowMs,
+        consecutiveErrorCount: nextCount,
+        ...(event.authIssue ? { authIssue: event.authIssue, reason: 'authVerify', inPool: false } : {})
+    };
+}
+export function applySuccessEvent(state, _event, nowMs = _event.timestampMs ?? Date.now()) {
+    const next = {
+        ...state,
+        lastErrorSeries: null,
+        lastErrorCode: null,
+        lastErrorAtMs: null,
+        consecutiveErrorCount: 0
+    };
+    return tickQuotaStateTime(next, nowMs);
+}

package/vendor/llmswitch-core/dist/quota/types.d.ts

@@ -0,0 +1,62 @@
+export type QuotaReason = 'ok' | 'cooldown' | 'blacklist' | 'quotaDepleted' | 'fatal' | 'authVerify';
+export type QuotaAuthType = 'apikey' | 'oauth' | 'unknown';
+export type QuotaAuthIssue = {
+    kind: 'google_account_verification';
+    url?: string | null;
+    message?: string | null;
+} | null;
+export interface StaticQuotaConfig {
+    priorityTier?: number | null;
+    authType?: QuotaAuthType | null;
+    /**
+     * Daily reset time for apikey quota exhaustion (HTTP 402).
+     * Format:
+     * - "HH:mm" => local time
+     * - "HH:mmZ" => UTC time
+     * If not set, defaults to 12:00 local.
+     */
+    apikeyDailyResetTime?: string | null;
+}
+export type ErrorSeries = 'E429' | 'E5XX' | 'ENET' | 'EFATAL' | 'EOTHER';
+export interface QuotaState {
+    providerKey: string;
+    inPool: boolean;
+    reason: QuotaReason;
+    authType: QuotaAuthType;
+    authIssue?: QuotaAuthIssue;
+    priorityTier: number;
+    cooldownUntil: number | null;
+    cooldownKeepsPool?: boolean;
+    blacklistUntil: number | null;
+    lastErrorSeries: ErrorSeries | null;
+    lastErrorCode: string | null;
+    lastErrorAtMs: number | null;
+    consecutiveErrorCount: number;
+}
+export interface ErrorEventForQuota {
+    providerKey: string;
+    code?: string | null;
+    httpStatus?: number | null;
+    fatal?: boolean | null;
+    timestampMs?: number;
+    /**
+     * Optional upstream resetAt ISO string for HTTP 402 quota depletion.
+     */
+    resetAt?: string | null;
+    /**
+     * Optional auth issue hint extracted by host/core adapters.
+     */
+    authIssue?: QuotaAuthIssue;
+}
+export interface SuccessEventForQuota {
+    providerKey: string;
+    timestampMs?: number;
+}
+export type QuotaStoreSnapshot = {
+    savedAtMs: number;
+    providers: Record<string, QuotaState>;
+};
+export interface QuotaStore {
+    load(): Promise<QuotaStoreSnapshot | null>;
+    save(snapshot: QuotaStoreSnapshot): Promise<void>;
+}

package/vendor/llmswitch-core/dist/quota/types.js

@@ -0,0 +1 @@
+export {};

package/vendor/llmswitch-core/dist/router/virtual-router/bootstrap/auth-utils.d.ts

@@ -0,0 +1,6 @@
+import { type ProviderAuthConfig } from '../types.js';
+export interface ProviderAuthEntry {
+    keyAlias: string;
+    auth: ProviderAuthConfig;
+}
+export declare function extractProviderAuthEntries(providerId: string, raw: unknown): ProviderAuthEntry[];

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

@@ -0,0 +1,288 @@
+import { scanDeepSeekAccountTokenFiles, scanOAuthTokenFiles } from '../token-file-scanner.js';
+import { VirtualRouterError, VirtualRouterErrorCode } from '../types.js';
+import { asRecord, normalizeAlias, pushUnique, readOptionalString } from './utils.js';
+const MULTI_TOKEN_OAUTH_PROVIDERS = new Set(['iflow', 'qwen', 'gemini-cli', 'antigravity']);
+export 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' && !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() }));
+    }
+    const hasExplicitEntries = entries.length > 0;
+    if (baseType === 'oauth' && !hasExplicitEntries) {
+        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);
+            }
+        }
+    }
+    const baseRawType = String(baseTypeInfo.raw ?? baseTypeSource ?? '').trim().toLowerCase();
+    if (baseType === 'apiKey' && baseRawType === 'deepseek-account' && !hasExplicitEntries) {
+        const tokenFiles = scanDeepSeekAccountTokenFiles();
+        for (const match of tokenFiles) {
+            const authConfig = {
+                ...defaults,
+                type: baseTypeSource ?? 'deepseek-account',
+                tokenFile: match.filePath
+            };
+            pushEntry(match.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),
+            cookieFile: readOptionalString(auth.cookieFile)
+        };
+        const fallbackHasData = Boolean(fallbackExtras.value ||
+            fallbackExtras.secretRef ||
+            fallbackExtras.tokenFile ||
+            fallbackExtras.tokenUrl ||
+            fallbackExtras.deviceCodeUrl ||
+            fallbackExtras.clientId ||
+            fallbackExtras.clientSecret ||
+            fallbackExtras.cookieFile ||
+            (fallbackExtras.scopes &&
+                Array.isArray(fallbackExtras.scopes) &&
+                fallbackExtras.scopes.length));
+        if (fallbackHasData) {
+            pushEntry(undefined, buildAuthCandidate(baseTypeSource, fallbackExtras));
+        }
+    }
+    if (!entries.length && baseType === 'apiKey') {
+        const authDeclared = Object.prototype.hasOwnProperty.call(provider, 'auth') ||
+            Object.prototype.hasOwnProperty.call(provider, 'apiKey') ||
+            Object.prototype.hasOwnProperty.call(provider, 'apiKeys') ||
+            Object.prototype.hasOwnProperty.call(provider, 'authType');
+        if (authDeclared) {
+            pushEntry(undefined, buildAuthCandidate(baseTypeSource, { value: '' }));
+        }
+    }
+    if (!entries.length) {
+        throw new VirtualRouterError(`Provider ${providerId} is missing auth configuration`, VirtualRouterErrorCode.CONFIG_ERROR);
+    }
+    return entries;
+}
+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 normalizeScopeList(value) {
+    if (Array.isArray(value)) {
+        const normalized = [];
+        for (const item of value) {
+            const str = readOptionalString(item);
+            if (str) {
+                pushUnique(normalized, str);
+            }
+        }
+        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 };
+}

package/vendor/llmswitch-core/dist/router/virtual-router/bootstrap/claude-code-helpers.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Claude Code specific helpers for Virtual Router bootstrap.
+ */
+export declare const CLAUDE_CODE_DEFAULT_USER_AGENT = "claude-cli/2.0.76 (external, cli)";
+export declare const CLAUDE_CODE_DEFAULT_X_APP = "claude-cli";
+export declare const CLAUDE_CODE_DEFAULT_ANTHROPIC_BETA = "claude-code";
+/**
+ * Parse the Claude Code app version from a user agent string.
+ * Returns the version string (e.g., "2.0.76") or null if not found.
+ */
+export declare function parseClaudeCodeAppVersionFromUserAgent(userAgent: string): string | null;

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

@@ -0,0 +1,18 @@
+/**
+ * Claude Code specific helpers for Virtual Router bootstrap.
+ */
+export const CLAUDE_CODE_DEFAULT_USER_AGENT = 'claude-cli/2.0.76 (external, cli)';
+export const CLAUDE_CODE_DEFAULT_X_APP = 'claude-cli';
+export const CLAUDE_CODE_DEFAULT_ANTHROPIC_BETA = 'claude-code';
+/**
+ * Parse the Claude Code app version from a user agent string.
+ * Returns the version string (e.g., "2.0.76") or null if not found.
+ */
+export function parseClaudeCodeAppVersionFromUserAgent(userAgent) {
+    const ua = typeof userAgent === 'string' ? userAgent.trim() : '';
+    if (!ua)
+        return null;
+    // Example: 'claude-cli/2.0.76 (external, cli)'
+    const match = /claude-cli\/([\d.]+)/.exec(ua);
+    return match?.[1] ?? null;
+}

package/vendor/llmswitch-core/dist/router/virtual-router/bootstrap/config-defaults.d.ts

@@ -0,0 +1,5 @@
+import type { LoadBalancingPolicy, ProviderHealthConfig, VirtualRouterClassifierConfig, VirtualRouterContextRoutingConfig } from '../types.js';
+export declare const DEFAULT_CLASSIFIER: Required<VirtualRouterClassifierConfig>;
+export declare const DEFAULT_LOAD_BALANCING: LoadBalancingPolicy;
+export declare const DEFAULT_HEALTH: ProviderHealthConfig;
+export declare const DEFAULT_CONTEXT_ROUTING: VirtualRouterContextRoutingConfig;

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

@@ -0,0 +1,13 @@
+export 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']
+};
+export const DEFAULT_LOAD_BALANCING = { strategy: 'round-robin' };
+export const DEFAULT_HEALTH = { failureThreshold: 3, cooldownMs: 30_000, fatalCooldownMs: 300_000 };
+export const DEFAULT_CONTEXT_ROUTING = {
+    warnRatio: 0.9,
+    hardLimit: false
+};

package/vendor/llmswitch-core/dist/router/virtual-router/bootstrap/config-normalizers.d.ts

@@ -0,0 +1,4 @@
+import type { VirtualRouterClockConfig, VirtualRouterConfig, VirtualRouterContextRoutingConfig } from '../types.js';
+export declare function normalizeExecCommandGuard(input: unknown): VirtualRouterConfig['execCommandGuard'] | undefined;
+export declare function normalizeClock(raw: unknown): VirtualRouterClockConfig | undefined;
+export declare function normalizeContextRouting(input: unknown): VirtualRouterContextRoutingConfig;