@jsonstudio/rcc 0.90.876 → 0.90.1270

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

@@ -1,7 +1,7 @@
 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']);
+const MULTI_TOKEN_OAUTH_PROVIDERS = new Set(['qwen', 'gemini-cli', 'antigravity']);
 export function extractProviderAuthEntries(providerId, raw) {
     const provider = asRecord(raw);
     const auth = asRecord(provider.auth);
@@ -120,6 +120,24 @@ export function extractProviderAuthEntries(providerId, raw) {
     else if (typeof apiKeyField === 'string' && apiKeyField.trim()) {
         pushEntry(undefined, buildAuthCandidate(baseTypeSource, { value: apiKeyField.trim() }));
     }
+    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 = hasAuthCandidateMaterial(fallbackExtras);
+    if (!entries.length && fallbackHasData) {
+        pushEntry(undefined, buildAuthCandidate(baseTypeSource, fallbackExtras));
+    }
     const hasExplicitEntries = entries.length > 0;
     if (baseType === 'oauth' && !hasExplicitEntries) {
         const scanCandidates = new Set();
@@ -169,36 +187,6 @@ export function extractProviderAuthEntries(providerId, raw) {
             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') ||
@@ -213,6 +201,20 @@ export function extractProviderAuthEntries(providerId, raw) {
     }
     return entries;
 }
+function hasAuthCandidateMaterial(candidate) {
+    return Boolean(candidate.value ||
+        candidate.secretRef ||
+        candidate.tokenFile ||
+        candidate.tokenUrl ||
+        candidate.deviceCodeUrl ||
+        candidate.clientId ||
+        candidate.clientSecret ||
+        candidate.authorizationUrl ||
+        candidate.userInfoUrl ||
+        candidate.refreshUrl ||
+        candidate.cookieFile ||
+        (Array.isArray(candidate.scopes) && candidate.scopes.length));
+}
 function collectAuthDefaults(auth) {
     return {
         secretRef: readOptionalString(auth.secretRef) ?? readOptionalString(auth.file),

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/bootstrap/provider-normalization.d.ts

@@ -1,6 +1,12 @@
 /**
  * Provider normalization logic for Virtual Router bootstrap.
  * Extracted from bootstrap.ts to improve modularity and testability.
+ *
+ * Step B: Hardcoded if-chains replaced with config-driven compat profile registry.
+ * - detectProviderType → detectProviderTypeFromConfig (provider-resolution-config.json)
+ * - mapOutboundProfile → resolveOutboundProfileFromConfig (provider-resolution-config.json)
+ * - resolveCompatibilityProfile defaults → resolveDefaultCompatibilityProfileFromConfig
+ * - maybeInjectQwenHeaders / maybeInjectClaudeCodeHeaders → applyHeaderPolicies (profile JSONs)
  */
 import { type ProviderAuthConfig, type ProviderRuntimeProfile, type DeepSeekCompatRuntimeOptions, type ResponsesProviderConfig, type ModelCapability, type AnthropicThinkingConfig, type AnthropicThinkingBudgetMap } from '../types.js';
 export interface ProviderAuthEntry {

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

@@ -1,12 +1,28 @@
 /**
  * Provider normalization logic for Virtual Router bootstrap.
  * Extracted from bootstrap.ts to improve modularity and testability.
+ *
+ * Step B: Hardcoded if-chains replaced with config-driven compat profile registry.
+ * - detectProviderType → detectProviderTypeFromConfig (provider-resolution-config.json)
+ * - mapOutboundProfile → resolveOutboundProfileFromConfig (provider-resolution-config.json)
+ * - resolveCompatibilityProfile defaults → resolveDefaultCompatibilityProfileFromConfig
+ * - maybeInjectQwenHeaders / maybeInjectClaudeCodeHeaders → applyHeaderPolicies (profile JSONs)
  */
 import { VirtualRouterError, VirtualRouterErrorCode } from '../types.js';
-import { CLAUDE_CODE_DEFAULT_USER_AGENT, CLAUDE_CODE_DEFAULT_X_APP, CLAUDE_CODE_DEFAULT_ANTHROPIC_BETA, parseClaudeCodeAppVersionFromUserAgent } from './claude-code-helpers.js';
 import { normalizeAnthropicThinking, normalizeModelCapabilities, normalizeResponsesConfig, resolveProviderStreamingPreference } from './responses-helpers.js';
 import { normalizeModelStreaming, normalizeModelContextTokens, normalizeModelOutputTokens } from './streaming-helpers.js';
+// Step B: Config-driven compat registry
+import { loadCompatProfileRegistry, getHeaderPolicies } from '../../../conversion/compat/profile-registry/registry.js';
+import { applyHeaderPolicies } from '../../../conversion/compat/profile-registry/header-policies.js';
+import { detectProviderTypeFromConfig, resolveOutboundProfileFromConfig, resolveDefaultCompatibilityProfileFromConfig } from '../../../conversion/compat/profile-registry/provider-resolver.js';
 const DEFAULT_PROVIDER_MAX_OUTPUT_TOKENS = 8192;
+// Load compat registry at module level (singleton, fail-fast on missing config)
+const compatRegistry = loadCompatProfileRegistry();
+const resolutionConfig = compatRegistry.providerResolutionConfig;
+if (!resolutionConfig) {
+    throw new Error('[provider-normalization] provider-resolution-config.json not found. ' +
+        'This file is required for config-driven provider type / outbound / compatibility resolution.');
+}
 /**
  * Normalize a raw provider configuration into a NormalizedProvider.
  */
@@ -26,7 +42,7 @@ export function normalizeProvider(providerId, raw) {
                 ? provider.baseUrl.trim()
                 : '';
     const compatibilityProfile = resolveCompatibilityProfile(providerId, provider);
-    const headers = maybeInjectClaudeCodeHeaders(providerId, providerType, compatibilityProfile, normalizeHeaders(provider.headers));
+    const headers = applyProfileHeaders(providerId, providerType, compatibilityProfile, normalizeHeaders(provider.headers));
     const responsesNode = asRecord(provider.responses);
     const responsesConfig = normalizeResponsesConfig({
         providerId,
@@ -78,50 +94,55 @@ export function normalizeProvider(providerId, raw) {
         ...(modelCapabilities ? { modelCapabilities } : {})
     };
 }
-function hasHeader(headers, name) {
-    if (!headers) {
-        return false;
-    }
-    const lowered = name.trim().toLowerCase();
-    if (!lowered) {
-        return false;
-    }
-    for (const key of Object.keys(headers)) {
-        if (key.trim().toLowerCase() === lowered) {
-            const value = headers[key];
-            if (typeof value === 'string' && value.trim()) {
-                return true;
-            }
-        }
-    }
-    return false;
+// ---------------------------------------------------------------------------
+// Config-driven header injection
+// Replaces: maybeInjectQwenHeaders + maybeInjectClaudeCodeHeaders
+// ---------------------------------------------------------------------------
+function applyProfileHeaders(providerId, providerType, compatibilityProfile, headers) {
+    // Look up header policy rules from the compat profile registry
+    const rules = getHeaderPolicies(compatRegistry, compatibilityProfile);
+    const result = applyHeaderPolicies(headers, rules, { providerId, providerType });
+    return result;
 }
-function maybeInjectClaudeCodeHeaders(_providerId, providerType, compatibilityProfile, headers) {
-    const profile = typeof compatibilityProfile === 'string' ? compatibilityProfile.trim().toLowerCase() : '';
-    if (!profile || (profile !== 'anthropic:claude-code' && profile !== 'chat:claude-code')) {
-        return headers;
-    }
-    if (!String(providerType).toLowerCase().includes('anthropic')) {
-        return headers;
-    }
-    const base = { ...(headers ?? {}) };
-    if (!hasHeader(base, 'User-Agent')) {
-        base['User-Agent'] = CLAUDE_CODE_DEFAULT_USER_AGENT;
+// ---------------------------------------------------------------------------
+// Config-driven detectProviderType
+// Delegates to detectProviderTypeFromConfig using provider-resolution-config.json
+// ---------------------------------------------------------------------------
+export function detectProviderType(provider) {
+    return detectProviderTypeFromConfig(resolutionConfig, provider);
+}
+// ---------------------------------------------------------------------------
+// Config-driven mapOutboundProfile
+// Delegates to resolveOutboundProfileFromConfig using provider-resolution-config.json
+// ---------------------------------------------------------------------------
+export function mapOutboundProfile(providerType) {
+    return resolveOutboundProfileFromConfig(resolutionConfig, providerType);
+}
+// ---------------------------------------------------------------------------
+// Config-driven resolveCompatibilityProfile
+// Explicit compatibilityProfile from provider config takes precedence.
+// Default resolution uses config-driven compatibilityProfileBlocks.
+// ---------------------------------------------------------------------------
+function resolveCompatibilityProfile(providerId, provider) {
+    if (typeof provider.compatibilityProfile === 'string' && provider.compatibilityProfile.trim()) {
+        return provider.compatibilityProfile.trim();
     }
-    if (!hasHeader(base, 'X-App')) {
-        base['X-App'] = CLAUDE_CODE_DEFAULT_X_APP;
+    const legacyFields = [];
+    if (typeof provider.compat === 'string') {
+        legacyFields.push('compat');
     }
-    if (!hasHeader(base, 'X-App-Version')) {
-        const version = parseClaudeCodeAppVersionFromUserAgent(base['User-Agent'] ?? '');
-        if (version) {
-            base['X-App-Version'] = version;
-        }
+    if (typeof provider.compatibility_profile === 'string') {
+        legacyFields.push('compatibility_profile');
     }
-    if (!hasHeader(base, 'anthropic-beta')) {
-        base['anthropic-beta'] = CLAUDE_CODE_DEFAULT_ANTHROPIC_BETA;
+    if (legacyFields.length > 0) {
+        throw new VirtualRouterError(`Provider "${providerId}" uses legacy compatibility field(s): ${legacyFields.join(', ')}. Rename to "compatibilityProfile".`, VirtualRouterErrorCode.CONFIG_ERROR);
     }
-    return base;
+    // Config-driven default resolution (replaces hardcoded antigravity/gemini-cli if-chain)
+    return resolveDefaultCompatibilityProfileFromConfig(resolutionConfig, providerId, provider);
 }
+// ---------------------------------------------------------------------------
+// Utilities (unchanged)
+// ---------------------------------------------------------------------------
 function normalizeDeepSeekOptions(provider) {
     const direct = asRecord(provider.deepseek);
     const ext = asRecord(asRecord(provider.extensions)?.deepseek);
@@ -155,30 +176,6 @@ function normalizeDeepSeekOptions(provider) {
         ...(toolProtocol !== undefined ? { toolProtocol } : {})
     };
 }
-function resolveCompatibilityProfile(providerId, provider) {
-    if (typeof provider.compatibilityProfile === 'string' && provider.compatibilityProfile.trim()) {
-        return provider.compatibilityProfile.trim();
-    }
-    const legacyFields = [];
-    if (typeof provider.compat === 'string') {
-        legacyFields.push('compat');
-    }
-    if (typeof provider.compatibility_profile === 'string') {
-        legacyFields.push('compatibility_profile');
-    }
-    if (legacyFields.length > 0) {
-        throw new VirtualRouterError(`Provider "${providerId}" uses legacy compatibility field(s): ${legacyFields.join(', ')}. Rename to "compatibilityProfile".`, VirtualRouterErrorCode.CONFIG_ERROR);
-    }
-    const normalizedId = providerId.trim().toLowerCase();
-    const providerType = String(provider.providerType ?? provider.type ?? provider.protocol ?? '').toLowerCase();
-    if (normalizedId === 'antigravity' ||
-        normalizedId === 'gemini-cli' ||
-        providerType.includes('antigravity') ||
-        providerType.includes('gemini-cli')) {
-        return 'chat:gemini-cli';
-    }
-    return 'compat:passthrough';
-}
 function normalizeProcessMode(value) {
     if (typeof value !== 'string') {
         return 'chat';
@@ -189,40 +186,23 @@ function normalizeProcessMode(value) {
     }
     return 'chat';
 }
-export 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';
-}
-export 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 hasHeader(headers, name) {
+    if (!headers) {
+        return false;
+    }
+    const lowered = name.trim().toLowerCase();
+    if (!lowered) {
+        return false;
+    }
+    for (const key of Object.keys(headers)) {
+        if (key.trim().toLowerCase() === lowered) {
+            const value = headers[key];
+            if (typeof value === 'string' && value.trim()) {
+                return true;
+            }
+        }
+    }
+    return false;
 }
 export function normalizeHeaders(input) {
     if (!input || typeof input !== 'object') {

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

@@ -29,8 +29,10 @@ export function normalizeResponsesConfig(options) {
 export function resolveProviderStreamingPreference(provider, responsesNode) {
     const configNode = asRecord(provider.config);
     const configResponses = configNode ? asRecord(configNode.responses) : undefined;
-    return (coerceStreamingPreference(provider.streaming ?? provider.stream ?? provider.supportsStreaming ?? provider.streamingPreference) ??
-        coerceStreamingPreference(responsesNode?.streaming ?? responsesNode?.stream ?? responsesNode?.supportsStreaming) ??
+    return (coerceStreamingPreference(provider.streaming ?? provider.stream ?? provider.streamingPreference) ??
+        coerceStreamingCapability(provider.supportsStreaming) ??
+        coerceStreamingPreference(responsesNode?.streaming ?? responsesNode?.stream) ??
+        coerceStreamingCapability(responsesNode?.supportsStreaming) ??
         coerceStreamingPreference(configResponses?.streaming ?? configResponses?.stream));
 }
 /**
@@ -66,6 +68,24 @@ function coerceStreamingPreference(value) {
     }
     return undefined;
 }
+function coerceStreamingCapability(value) {
+    if (typeof value === 'boolean') {
+        return value ? 'auto' : 'never';
+    }
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        const record = value;
+        if (record.enabled !== undefined) {
+            return coerceStreamingCapability(record.enabled);
+        }
+        if (record.value !== undefined) {
+            return coerceStreamingCapability(record.value);
+        }
+        if (record.mode !== undefined) {
+            return coerceStreamingCapability(record.mode);
+        }
+    }
+    return coerceStreamingPreference(value);
+}
 export function normalizeModelCapabilities(provider) {
     const models = provider.models;
     const result = {};

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

@@ -133,7 +133,9 @@ function normalizeRoutePoolEntry(routeName, entry, index, total) {
     const priority = normalizePriorityValue(record.priority, total - index);
     const loadBalancing = normalizeRoutePoolLoadBalancing(record.loadBalancing);
     const targets = normalizeRouteTargets(record, loadBalancing);
-    const mode = normalizeRoutePoolMode(record.mode ?? record.strategy ?? record.routingMode);
+    const explicitMode = normalizeRoutePoolMode(record.mode ?? record.strategy ?? record.routingMode);
+    const mode = explicitMode ??
+        inferRoutePoolModeFromConfig(record, targets, loadBalancing);
     const force = record.force === true ||
         (typeof record.force === 'string' && record.force.trim().toLowerCase() === 'true');
     return targets.length
@@ -148,6 +150,30 @@ function normalizeRoutePoolEntry(routeName, entry, index, total) {
         }
         : null;
 }
+function inferRoutePoolModeFromConfig(record, targets, loadBalancing) {
+    if (!targets.length) {
+        return undefined;
+    }
+    if (hasExplicitRouteTargets(record)) {
+        return undefined;
+    }
+    const nested = asLoadBalancingRecord(record.loadBalancing);
+    const hasNestedOrderedTargets = normalizeTargetList(nested?.targets).length > 0 ||
+        normalizeTargetList(nested?.providers).length > 0 ||
+        normalizeTargetList(nested?.order).length > 0 ||
+        normalizeTargetList(nested?.entries).length > 0 ||
+        normalizeTargetList(nested?.items).length > 0 ||
+        normalizeTargetList(nested?.routes).length > 0 ||
+        normalizeTargetList(nested?.target).length > 0 ||
+        normalizeTargetList(nested?.provider).length > 0;
+    if (hasNestedOrderedTargets) {
+        return 'priority';
+    }
+    if (loadBalancing?.weights && Object.keys(loadBalancing.weights).length > 0) {
+        return 'priority';
+    }
+    return undefined;
+}
 function normalizeRoutePoolLoadBalancing(input) {
     if (!input || typeof input !== 'object' || Array.isArray(input)) {
         return undefined;
@@ -210,7 +236,21 @@ function normalizeRoutePoolMode(value) {
     return undefined;
 }
 function normalizeRouteTargets(record, loadBalancing) {
-    const buckets = [record.targets, record.providers, record.pool, record.entries, record.items, record.routes];
+    const loadBalancingRecord = asLoadBalancingRecord(record.loadBalancing);
+    const buckets = [
+        record.targets,
+        record.providers,
+        record.pool,
+        record.entries,
+        record.items,
+        record.routes,
+        loadBalancingRecord?.targets,
+        loadBalancingRecord?.providers,
+        loadBalancingRecord?.order,
+        loadBalancingRecord?.entries,
+        loadBalancingRecord?.items,
+        loadBalancingRecord?.routes
+    ];
     const normalized = [];
     for (const bucket of buckets) {
         for (const target of normalizeTargetList(bucket)) {
@@ -219,7 +259,7 @@ function normalizeRouteTargets(record, loadBalancing) {
             }
         }
     }
-    const singular = [record.target, record.provider];
+    const singular = [record.target, record.provider, loadBalancingRecord?.target, loadBalancingRecord?.provider];
     for (const candidate of singular) {
         for (const target of normalizeTargetList(candidate)) {
             if (!normalized.includes(target)) {
@@ -237,6 +277,19 @@ function normalizeRouteTargets(record, loadBalancing) {
     }
     return normalized;
 }
+function asLoadBalancingRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}
+function hasExplicitRouteTargets(record) {
+    const explicitBuckets = [record.targets, record.providers, record.pool, record.entries, record.items, record.routes];
+    if (explicitBuckets.some((bucket) => normalizeTargetList(bucket).length > 0)) {
+        return true;
+    }
+    return normalizeTargetList(record.target).length > 0 || normalizeTargetList(record.provider).length > 0;
+}
 function normalizeTargetList(value) {
     if (Array.isArray(value)) {
         const normalized = [];

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

@@ -25,7 +25,7 @@ export function normalizeModelStreaming(provider) {
 function resolveStreamingPreference(model) {
     return (coerceStreamingPreference(model.streaming) ??
         coerceStreamingPreference(model.stream) ??
-        coerceStreamingPreference(model.supportsStreaming));
+        coerceStreamingCapability(model.supportsStreaming));
 }
 /**
  * Coerce various value types to StreamingPreference.
@@ -60,6 +60,24 @@ function coerceStreamingPreference(value) {
     }
     return undefined;
 }
+function coerceStreamingCapability(value) {
+    if (typeof value === 'boolean') {
+        return value ? 'auto' : 'never';
+    }
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        const record = value;
+        if (record.enabled !== undefined) {
+            return coerceStreamingCapability(record.enabled);
+        }
+        if (record.value !== undefined) {
+            return coerceStreamingCapability(record.value);
+        }
+        if (record.mode !== undefined) {
+            return coerceStreamingCapability(record.mode);
+        }
+    }
+    return coerceStreamingPreference(value);
+}
 /**
  * Normalize model-level context token limits.
  */