@jsonstudio/llms 0.6.1892 → 0.6.2172

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

@@ -0,0 +1,68 @@
+import { DEFAULT_MODEL_CONTEXT_TOKENS, VirtualRouterError, VirtualRouterErrorCode } from '../types.js';
+import { buildRuntimeKey, parseTargetKey } from './routing-config.js';
+export function buildProviderProfiles(targetKeys, runtimeEntries) {
+    const profiles = {};
+    const targetRuntime = {};
+    for (const targetKey of targetKeys) {
+        const parsed = parseTargetKey(targetKey);
+        if (!parsed)
+            continue;
+        const runtimeKey = buildRuntimeKey(parsed.providerId, parsed.keyAlias);
+        const runtime = runtimeEntries[runtimeKey];
+        if (!runtime) {
+            throw new VirtualRouterError(`Routing target ${targetKey} references unknown runtime key ${runtimeKey}`, VirtualRouterErrorCode.CONFIG_ERROR);
+        }
+        const streamingPref = runtime.modelStreaming?.[parsed.modelId] !== undefined
+            ? runtime.modelStreaming?.[parsed.modelId]
+            : runtime.streaming;
+        const contextTokens = resolveContextTokens(runtime, parsed.modelId);
+        profiles[targetKey] = {
+            providerKey: targetKey,
+            providerType: runtime.providerType,
+            endpoint: runtime.endpoint,
+            auth: { ...runtime.auth },
+            outboundProfile: runtime.outboundProfile,
+            compatibilityProfile: runtime.compatibilityProfile,
+            runtimeKey,
+            modelId: parsed.modelId,
+            processMode: runtime.processMode || 'chat',
+            responsesConfig: runtime.responsesConfig,
+            streaming: streamingPref,
+            maxContextTokens: contextTokens,
+            ...(runtime.deepseek ? { deepseek: runtime.deepseek } : {}),
+            ...(runtime.serverToolsDisabled ? { serverToolsDisabled: true } : {})
+        };
+        targetRuntime[targetKey] = {
+            ...runtime,
+            modelId: parsed.modelId,
+            streaming: streamingPref,
+            maxContextTokens: contextTokens
+        };
+    }
+    return { profiles, targetRuntime };
+}
+export function resolveContextTokens(runtime, modelId) {
+    const specific = runtime.modelContextTokens?.[modelId];
+    if (typeof specific === 'number' && Number.isFinite(specific) && specific > 0) {
+        return Math.floor(specific);
+    }
+    const fallback = runtime.defaultContextTokens ?? runtime.maxContextTokens;
+    if (typeof fallback === 'number' && Number.isFinite(fallback) && fallback > 0) {
+        return Math.floor(fallback);
+    }
+    return DEFAULT_MODEL_CONTEXT_TOKENS;
+}
+export function normalizeHealth(input) {
+    if (!input || typeof input !== 'object')
+        return undefined;
+    const record = input;
+    const failureThreshold = typeof record.failureThreshold === 'number' ? record.failureThreshold : undefined;
+    const cooldownMs = typeof record.cooldownMs === 'number' ? record.cooldownMs : undefined;
+    const fatalCooldownMs = typeof record.fatalCooldownMs === 'number' ? record.fatalCooldownMs : undefined;
+    if (typeof failureThreshold !== 'number' || typeof cooldownMs !== 'number') {
+        return undefined;
+    }
+    return fatalCooldownMs !== undefined
+        ? { failureThreshold, cooldownMs, fatalCooldownMs }
+        : { failureThreshold, cooldownMs };
+}

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

@@ -0,0 +1,40 @@
+/**
+ * Provider normalization logic for Virtual Router bootstrap.
+ * Extracted from bootstrap.ts to improve modularity and testability.
+ */
+import { type ProviderAuthConfig, type ProviderRuntimeProfile, type DeepSeekCompatRuntimeOptions, type ResponsesProviderConfig } from '../types.js';
+export interface ProviderAuthEntry {
+    keyAlias: string;
+    auth: ProviderAuthConfig;
+}
+export interface NormalizedProvider {
+    providerId: string;
+    providerType: string;
+    endpoint: string;
+    headers?: Record<string, string>;
+    outboundProfile: string;
+    compatibilityProfile: string;
+    processMode: 'chat' | 'passthrough';
+    responsesConfig?: ResponsesProviderConfig;
+    streaming?: 'always' | 'auto' | 'never';
+    modelStreaming?: Record<string, 'always' | 'auto' | 'never'>;
+    modelContextTokens?: Record<string, number>;
+    defaultContextTokens?: number;
+    deepseek?: DeepSeekCompatRuntimeOptions;
+    serverToolsDisabled?: boolean;
+}
+export interface ProviderRuntimeBuildResult {
+    runtimeEntries: Record<string, ProviderRuntimeProfile>;
+    aliasIndex: Map<string, string[]>;
+    modelIndex: Map<string, {
+        declared: boolean;
+        models: string[];
+    }>;
+}
+/**
+ * Normalize a raw provider configuration into a NormalizedProvider.
+ */
+export declare function normalizeProvider(providerId: string, raw: unknown): NormalizedProvider;
+export declare function detectProviderType(provider: Record<string, unknown>): string;
+export declare function mapOutboundProfile(providerType: string): string;
+export declare function normalizeHeaders(input: unknown): Record<string, string> | undefined;

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

@@ -0,0 +1,212 @@
+/**
+ * Provider normalization logic for Virtual Router bootstrap.
+ * Extracted from bootstrap.ts to improve modularity and testability.
+ */
+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 { normalizeResponsesConfig, resolveProviderStreamingPreference } from './responses-helpers.js';
+import { normalizeModelStreaming, normalizeModelContextTokens } from './streaming-helpers.js';
+/**
+ * Normalize a raw provider configuration into a NormalizedProvider.
+ */
+export function normalizeProvider(providerId, raw) {
+    const provider = asRecord(raw);
+    const providerType = detectProviderType(provider);
+    const endpoint = typeof provider.endpoint === 'string' && provider.endpoint.trim()
+        ? provider.endpoint.trim()
+        : typeof provider.baseURL === 'string' && provider.baseURL.trim()
+            ? provider.baseURL.trim()
+            : typeof provider.baseUrl === 'string' && provider.baseUrl.trim()
+                ? provider.baseUrl.trim()
+                : '';
+    const compatibilityProfile = resolveCompatibilityProfile(providerId, provider);
+    const headers = maybeInjectClaudeCodeHeaders(providerId, providerType, compatibilityProfile, normalizeHeaders(provider.headers));
+    const responsesNode = asRecord(provider.responses);
+    const responsesConfig = normalizeResponsesConfig({
+        providerId,
+        providerType,
+        compatibilityProfile,
+        provider,
+        node: responsesNode
+    });
+    const processMode = normalizeProcessMode(provider.process);
+    const streaming = resolveProviderStreamingPreference(provider, responsesNode);
+    const modelStreaming = normalizeModelStreaming(provider);
+    const { modelContextTokens, defaultContextTokens } = normalizeModelContextTokens(provider);
+    const deepseek = normalizeDeepSeekOptions(provider);
+    const serverToolsDisabled = provider.serverToolsDisabled === true ||
+        (typeof provider.serverToolsDisabled === 'string' &&
+            provider.serverToolsDisabled.trim().toLowerCase() === 'true') ||
+        (provider.serverTools &&
+            typeof provider.serverTools === 'object' &&
+            provider.serverTools.enabled === false);
+    return {
+        providerId,
+        providerType,
+        endpoint,
+        headers,
+        outboundProfile: mapOutboundProfile(providerType),
+        compatibilityProfile,
+        processMode,
+        responsesConfig,
+        streaming,
+        modelStreaming,
+        modelContextTokens,
+        defaultContextTokens,
+        ...(deepseek ? { deepseek } : {}),
+        ...(serverToolsDisabled ? { serverToolsDisabled: true } : {})
+    };
+}
+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;
+}
+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;
+    }
+    if (!hasHeader(base, 'X-App')) {
+        base['X-App'] = CLAUDE_CODE_DEFAULT_X_APP;
+    }
+    if (!hasHeader(base, 'X-App-Version')) {
+        const version = parseClaudeCodeAppVersionFromUserAgent(base['User-Agent'] ?? '');
+        if (version) {
+            base['X-App-Version'] = version;
+        }
+    }
+    if (!hasHeader(base, 'anthropic-beta')) {
+        base['anthropic-beta'] = CLAUDE_CODE_DEFAULT_ANTHROPIC_BETA;
+    }
+    return base;
+}
+function normalizeDeepSeekOptions(provider) {
+    const direct = asRecord(provider.deepseek);
+    const ext = asRecord(asRecord(provider.extensions)?.deepseek);
+    const source = Object.keys(direct).length ? direct : ext;
+    if (!source || !Object.keys(source).length) {
+        return undefined;
+    }
+    const strictToolRequired = typeof source.strictToolRequired === 'boolean'
+        ? source.strictToolRequired
+        : typeof source.strictToolRequired === 'string'
+            ? source.strictToolRequired.trim().toLowerCase() === 'true'
+            : undefined;
+    const textToolFallback = typeof source.textToolFallback === 'boolean'
+        ? source.textToolFallback
+        : typeof source.textToolFallback === 'string'
+            ? source.textToolFallback.trim().toLowerCase() === 'true'
+            : undefined;
+    if (strictToolRequired === undefined && textToolFallback === undefined) {
+        return undefined;
+    }
+    return {
+        ...(strictToolRequired !== undefined ? { strictToolRequired } : {}),
+        ...(textToolFallback !== undefined ? { textToolFallback } : {})
+    };
+}
+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';
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'passthrough') {
+        return 'passthrough';
+    }
+    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';
+}
+export function normalizeHeaders(input) {
+    if (!input || typeof input !== 'object') {
+        return undefined;
+    }
+    const entries = {};
+    for (const [key, value] of Object.entries(input)) {
+        if (typeof value === 'string') {
+            entries[key] = value;
+        }
+    }
+    return Object.keys(entries).length ? entries : undefined;
+}
+function asRecord(value) {
+    return (value && typeof value === 'object' ? value : {});
+}

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

@@ -0,0 +1,15 @@
+import { type ResponsesProviderConfig, type StreamingPreference } from '../types.js';
+/**
+ * Normalize responses provider config.
+ */
+export declare function normalizeResponsesConfig(options: {
+    providerId: string;
+    providerType: string;
+    compatibilityProfile: string;
+    provider: Record<string, unknown>;
+    node?: Record<string, unknown>;
+}): ResponsesProviderConfig | undefined;
+/**
+ * Resolve provider-level streaming preference.
+ */
+export declare function resolveProviderStreamingPreference(provider: Record<string, unknown>, responsesNode?: Record<string, unknown>): StreamingPreference | undefined;

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

@@ -0,0 +1,65 @@
+import { asRecord } from './utils.js';
+/**
+ * Normalize responses provider config.
+ */
+export function normalizeResponsesConfig(options) {
+    const source = options.node ?? asRecord(options.provider.responses);
+    const rawStyle = typeof source.toolCallIdStyle === 'string' ? source.toolCallIdStyle.trim().toLowerCase() : undefined;
+    if (rawStyle === 'fc' || rawStyle === 'preserve') {
+        return { toolCallIdStyle: rawStyle };
+    }
+    const providerType = typeof options.providerType === 'string' ? options.providerType.trim().toLowerCase() : '';
+    if (!providerType.includes('responses')) {
+        return undefined;
+    }
+    const providerId = typeof options.providerId === 'string' ? options.providerId.trim().toLowerCase() : '';
+    const compat = typeof options.compatibilityProfile === 'string' ? options.compatibilityProfile.trim().toLowerCase() : '';
+    // Default tool-call id style:
+    // - Standard OpenAI /v1/responses requires function_call ids to start with "fc_".
+    // - LM Studio (OpenAI-compatible) often emits `call_*` ids and expects them to be preserved.
+    const isLmstudio = providerId === 'lmstudio' || compat === 'chat:lmstudio';
+    return { toolCallIdStyle: isLmstudio ? 'preserve' : 'fc' };
+}
+/**
+ * Resolve provider-level streaming preference.
+ */
+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) ??
+        coerceStreamingPreference(configResponses?.streaming ?? configResponses?.stream));
+}
+/**
+ * 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;
+}

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

@@ -0,0 +1,23 @@
+import { type RoutingPools } from '../types.js';
+export interface NormalizedRoutePoolConfig {
+    id: string;
+    priority: number;
+    backup: boolean;
+    targets: string[];
+    mode?: 'round-robin' | 'priority';
+    force?: boolean;
+}
+export declare function normalizeRouting(source: Record<string, unknown>): Record<string, NormalizedRoutePoolConfig[]>;
+export declare function expandRoutingTable(routingSource: Record<string, NormalizedRoutePoolConfig[]>, aliasIndex: Map<string, string[]>, modelIndex: Map<string, {
+    declared: boolean;
+    models: string[];
+}>): {
+    routing: RoutingPools;
+    targetKeys: Set<string>;
+};
+export declare function parseTargetKey(targetKey: string): {
+    providerId: string;
+    keyAlias: string;
+    modelId: string;
+} | null;
+export declare function buildRuntimeKey(providerId: string, keyAlias: string): string;