@jsonstudio/rcc 0.90.352 → 0.90.367

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

@@ -0,0 +1,106 @@
+import { DEFAULT_CONTEXT_ROUTING } from './config-defaults.js';
+export function normalizeExecCommandGuard(input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input)) {
+        return undefined;
+    }
+    const record = input;
+    const enabledRaw = record.enabled;
+    const enabled = enabledRaw === true ||
+        (typeof enabledRaw === 'string' && enabledRaw.trim().toLowerCase() === 'true') ||
+        (typeof enabledRaw === 'number' && enabledRaw === 1);
+    if (!enabled) {
+        return undefined;
+    }
+    const policyFileRaw = record.policyFile ?? record.policy_file;
+    const policyFile = typeof policyFileRaw === 'string' && policyFileRaw.trim().length ? policyFileRaw.trim() : undefined;
+    return {
+        enabled: true,
+        ...(policyFile ? { policyFile } : {})
+    };
+}
+export function normalizeClock(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return undefined;
+    }
+    const record = raw;
+    const enabled = record.enabled === true ||
+        (typeof record.enabled === 'string' && record.enabled.trim().toLowerCase() === 'true') ||
+        (typeof record.enabled === 'number' && record.enabled === 1);
+    if (!enabled) {
+        return undefined;
+    }
+    const out = { enabled: true };
+    if (typeof record.retentionMs === 'number' && Number.isFinite(record.retentionMs) && record.retentionMs >= 0) {
+        out.retentionMs = Math.floor(record.retentionMs);
+    }
+    if (typeof record.dueWindowMs === 'number' && Number.isFinite(record.dueWindowMs) && record.dueWindowMs >= 0) {
+        out.dueWindowMs = Math.floor(record.dueWindowMs);
+    }
+    if (typeof record.tickMs === 'number' && Number.isFinite(record.tickMs) && record.tickMs >= 0) {
+        out.tickMs = Math.floor(record.tickMs);
+    }
+    if (record.holdNonStreaming === true ||
+        (typeof record.holdNonStreaming === 'string' && record.holdNonStreaming.trim().toLowerCase() === 'true') ||
+        (typeof record.holdNonStreaming === 'number' && record.holdNonStreaming === 1)) {
+        out.holdNonStreaming = true;
+    }
+    if (typeof record.holdMaxMs === 'number' && Number.isFinite(record.holdMaxMs) && record.holdMaxMs >= 0) {
+        out.holdMaxMs = Math.floor(record.holdMaxMs);
+    }
+    return out;
+}
+export function normalizeContextRouting(input) {
+    if (!input || typeof input !== 'object') {
+        return { ...DEFAULT_CONTEXT_ROUTING };
+    }
+    const record = input;
+    const warnCandidate = coerceRatio(record.warnRatio) ?? coerceRatio(record.warn_ratio);
+    const hardLimitCandidate = coerceBoolean(record.hardLimit) ?? coerceBoolean(record.hard_limit);
+    const warnRatio = clampWarnRatio(warnCandidate ?? DEFAULT_CONTEXT_ROUTING.warnRatio);
+    const hardLimit = typeof hardLimitCandidate === 'boolean' ? hardLimitCandidate : DEFAULT_CONTEXT_ROUTING.hardLimit;
+    return {
+        warnRatio,
+        hardLimit
+    };
+}
+function coerceRatio(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (!trimmed) {
+            return undefined;
+        }
+        const parsed = Number(trimmed);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return undefined;
+}
+function clampWarnRatio(value) {
+    if (!Number.isFinite(value)) {
+        return DEFAULT_CONTEXT_ROUTING.warnRatio;
+    }
+    const clamped = Math.max(0.1, Math.min(value, 0.99));
+    return Number.isFinite(clamped) ? clamped : DEFAULT_CONTEXT_ROUTING.warnRatio;
+}
+function coerceBoolean(value) {
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        const normalized = value.trim().toLowerCase();
+        if (!normalized) {
+            return undefined;
+        }
+        if (['true', '1', 'yes', 'y'].includes(normalized)) {
+            return true;
+        }
+        if (['false', '0', 'no', 'n'].includes(normalized)) {
+            return false;
+        }
+    }
+    return undefined;
+}

package/vendor/llmswitch-core/dist/router/virtual-router/bootstrap/profile-builder.d.ts

@@ -0,0 +1,8 @@
+import { type ProviderHealthConfig, type ProviderProfile, type ProviderRuntimeProfile } from '../types.js';
+export declare function buildProviderProfiles(targetKeys: Set<string>, runtimeEntries: Record<string, ProviderRuntimeProfile>): {
+    profiles: Record<string, ProviderProfile>;
+    targetRuntime: Record<string, ProviderRuntimeProfile>;
+};
+export declare function resolveContextTokens(runtime: ProviderRuntimeProfile, modelId: string): number;
+export declare function resolveOutputTokens(runtime: ProviderRuntimeProfile, modelId: string): number | undefined;
+export declare function normalizeHealth(input: unknown): ProviderHealthConfig | undefined;

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

@@ -0,0 +1,87 @@
+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 modelStreamingPref = runtime.modelStreaming?.[parsed.modelId];
+        const streamingPref = runtime.streaming === 'always' || runtime.streaming === 'never'
+            ? runtime.streaming
+            : modelStreamingPref !== undefined
+                ? modelStreamingPref
+                : runtime.streaming;
+        const contextTokens = resolveContextTokens(runtime, parsed.modelId);
+        const outputTokens = resolveOutputTokens(runtime, parsed.modelId);
+        const modelCapabilities = runtime.modelCapabilities;
+        profiles[targetKey] = {
+            providerKey: targetKey,
+            providerType: runtime.providerType,
+            endpoint: runtime.endpoint,
+            auth: { ...runtime.auth },
+            ...(runtime.enabled !== undefined ? { enabled: runtime.enabled } : {}),
+            outboundProfile: runtime.outboundProfile,
+            compatibilityProfile: runtime.compatibilityProfile,
+            runtimeKey,
+            modelId: parsed.modelId,
+            processMode: runtime.processMode || 'chat',
+            responsesConfig: runtime.responsesConfig,
+            streaming: streamingPref,
+            maxOutputTokens: outputTokens,
+            maxContextTokens: contextTokens,
+            ...(runtime.deepseek ? { deepseek: runtime.deepseek } : {}),
+            ...(runtime.serverToolsDisabled ? { serverToolsDisabled: true } : {}),
+            ...(modelCapabilities ? { modelCapabilities } : {})
+        };
+        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 resolveOutputTokens(runtime, modelId) {
+    const specific = runtime.modelOutputTokens?.[modelId];
+    if (typeof specific === 'number' && Number.isFinite(specific) && specific > 0) {
+        return Math.floor(specific);
+    }
+    const fallback = runtime.defaultOutputTokens;
+    if (typeof fallback === 'number' && Number.isFinite(fallback) && fallback > 0) {
+        return Math.floor(fallback);
+    }
+    return undefined;
+}
+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/vendor/llmswitch-core/dist/router/virtual-router/bootstrap/provider-normalization.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 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, type ModelCapability } from '../types.js';
+export interface ProviderAuthEntry {
+    keyAlias: string;
+    auth: ProviderAuthConfig;
+}
+export interface NormalizedProvider {
+    providerId: string;
+    providerType: string;
+    endpoint: string;
+    headers?: Record<string, string>;
+    enabled?: boolean;
+    outboundProfile: string;
+    compatibilityProfile: string;
+    processMode: 'chat' | 'passthrough';
+    responsesConfig?: ResponsesProviderConfig;
+    streaming?: 'always' | 'auto' | 'never';
+    modelStreaming?: Record<string, 'always' | 'auto' | 'never'>;
+    modelOutputTokens?: Record<string, number>;
+    defaultOutputTokens?: number;
+    modelContextTokens?: Record<string, number>;
+    defaultContextTokens?: number;
+    deepseek?: DeepSeekCompatRuntimeOptions;
+    serverToolsDisabled?: boolean;
+    modelCapabilities?: Record<string, ModelCapability[]>;
+}
+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/vendor/llmswitch-core/dist/router/virtual-router/bootstrap/provider-normalization.js

@@ -0,0 +1,272 @@
+/**
+ * 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, normalizeModelOutputTokens } from './streaming-helpers.js';
+const DEFAULT_PROVIDER_MAX_OUTPUT_TOKENS = 8192;
+/**
+ * Normalize a raw provider configuration into a NormalizedProvider.
+ */
+export function normalizeProvider(providerId, raw) {
+    const provider = asRecord(raw);
+    const enabled = typeof provider.enabled === 'boolean'
+        ? provider.enabled
+        : typeof provider.enabled === 'string'
+            ? provider.enabled.trim().toLowerCase() !== 'false'
+            : undefined;
+    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 { modelOutputTokens, defaultOutputTokens: explicitDefaultOutputTokens } = normalizeModelOutputTokens(provider);
+    const defaultOutputTokens = explicitDefaultOutputTokens ??
+        (processMode === 'passthrough' ? undefined : DEFAULT_PROVIDER_MAX_OUTPUT_TOKENS);
+    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);
+    const modelCapabilities = normalizeModelCapabilities(provider);
+    return {
+        providerId,
+        providerType,
+        endpoint,
+        headers,
+        ...(enabled !== undefined ? { enabled } : {}),
+        outboundProfile: mapOutboundProfile(providerType),
+        compatibilityProfile,
+        processMode,
+        responsesConfig,
+        streaming,
+        modelStreaming,
+        modelOutputTokens,
+        defaultOutputTokens,
+        modelContextTokens,
+        defaultContextTokens,
+        ...(deepseek ? { deepseek } : {}),
+        ...(serverToolsDisabled ? { serverToolsDisabled: true } : {}),
+        ...(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;
+}
+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 toolProtocolRaw = typeof source.toolProtocol === 'string' ? source.toolProtocol.trim().toLowerCase() : '';
+    let toolProtocol;
+    if (toolProtocolRaw === 'text' || toolProtocolRaw === 'native') {
+        toolProtocol = toolProtocolRaw;
+    }
+    const legacyTextToolFallback = typeof source.textToolFallback === 'boolean'
+        ? source.textToolFallback
+        : typeof source.textToolFallback === 'string'
+            ? source.textToolFallback.trim().toLowerCase() === 'true'
+            : undefined;
+    if (toolProtocol === undefined && legacyTextToolFallback !== undefined) {
+        toolProtocol = legacyTextToolFallback ? 'text' : 'native';
+    }
+    if (strictToolRequired === undefined && toolProtocol === undefined) {
+        return undefined;
+    }
+    return {
+        ...(strictToolRequired !== undefined ? { strictToolRequired } : {}),
+        ...(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';
+    }
+    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 : {});
+}
+function normalizeModelCapabilities(provider) {
+    const models = provider.models;
+    const result = {};
+    const pushCapabilities = (modelId, capabilities) => {
+        if (!modelId)
+            return;
+        if (!Array.isArray(capabilities))
+            return;
+        const valid = [];
+        for (const cap of capabilities) {
+            if (typeof cap === 'string' && ['text', 'reasoning', 'vision', 'thinking', 'web_search'].includes(cap)) {
+                valid.push(cap);
+            }
+        }
+        if (valid.length > 0) {
+            result[modelId] = valid;
+        }
+    };
+    if (Array.isArray(models)) {
+        for (const model of models) {
+            if (!model || typeof model !== 'object') {
+                continue;
+            }
+            const modelObj = model;
+            const modelId = typeof modelObj.id === 'string' ? modelObj.id.trim() : '';
+            pushCapabilities(modelId, modelObj.capabilities);
+        }
+    }
+    else if (models && typeof models === 'object') {
+        const modelsNode = models;
+        for (const [modelName, modelConfigRaw] of Object.entries(modelsNode)) {
+            const modelId = typeof modelName === 'string' ? modelName.trim() : '';
+            const modelConfig = typeof modelConfigRaw === 'object' && modelConfigRaw ? modelConfigRaw : {};
+            pushCapabilities(modelId, modelConfig.capabilities);
+        }
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+}

package/vendor/llmswitch-core/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/vendor/llmswitch-core/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/vendor/llmswitch-core/dist/router/virtual-router/bootstrap/routing-config.d.ts

@@ -0,0 +1,24 @@
+import { type RoutingPools, type RoutePoolLoadBalancingPolicy } from '../types.js';
+export interface NormalizedRoutePoolConfig {
+    id: string;
+    priority: number;
+    backup: boolean;
+    targets: string[];
+    mode?: 'round-robin' | 'priority';
+    force?: boolean;
+    loadBalancing?: RoutePoolLoadBalancingPolicy;
+}
+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;