@jsonstudio/llms 0.6.3379 → 0.6.3409

package/dist/conversion/shared/tool-call-id-manager.js

@@ -35,11 +35,9 @@ export class ToolCallIdManager {
      */
     generateId() {
         assertToolCallIdManagerNativeAvailable();
-        if (this.options.style === 'fc') {
-            const next = transformToolCallIdWithNative(this.state, '').id;
-            return next;
-        }
-        return normalizeIdValueWithNative(undefined, true);
+        const output = transformToolCallIdWithNative(this.state, '');
+        this.state = output.state;
+        return output.id;
     }
     /**
      * 规范化工具调用 ID
@@ -50,13 +48,9 @@ export class ToolCallIdManager {
     normalizeId(id) {
         assertToolCallIdManagerNativeAvailable();
         const raw = typeof id === 'string' ? id : '';
-        if (this.options.style === 'fc') {
-            const output = transformToolCallIdWithNative(this.state, raw);
-            this.state = output.state;
-            return output.id;
-        }
-        const trimmed = raw.trim();
-        return trimmed ? trimmed : normalizeIdValueWithNative(undefined, true);
+        const output = transformToolCallIdWithNative(this.state, raw);
+        this.state = output.state;
+        return output.id;
     }
     /**
      * 规范化工具调用 ID（带别名注册）
@@ -68,18 +62,21 @@ export class ToolCallIdManager {
     normalizeIdWithAlias(id, aliasMap) {
         assertToolCallIdManagerNativeAvailable();
         const raw = typeof id === 'string' ? id : '';
-        if (this.options.style !== 'preserve') {
-            return this.normalizeId(raw);
-        }
         const trimmed = raw.trim();
-        if (trimmed && aliasMap && aliasMap.has(trimmed)) {
-            return aliasMap.get(trimmed);
+        if (this.options.style === 'preserve' && trimmed && aliasMap?.has(trimmed)) {
+            const existing = aliasMap.get(trimmed);
+            const aliasState = this.state.aliasMap;
+            if (aliasState && typeof aliasState === 'object') {
+                aliasState[trimmed] = existing;
+            }
+            return existing;
         }
-        const value = trimmed || normalizeIdValueWithNative(undefined, true);
-        if (trimmed && aliasMap) {
-            aliasMap.set(trimmed, value);
+        const output = transformToolCallIdWithNative(this.state, raw);
+        this.state = output.state;
+        if (this.options.style === 'preserve' && trimmed && aliasMap) {
+            aliasMap.set(trimmed, output.id);
         }
-        return value;
+        return output.id;
     }
     /**
      * 批量规范化工具调用 ID

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

@@ -1,4 +1,4 @@
-import { type RoutingPools } from '../types.js';
+import { type RoutingPools, type RoutePoolLoadBalancingPolicy } from '../types.js';
 export interface NormalizedRoutePoolConfig {
     id: string;
     priority: number;
@@ -6,6 +6,7 @@ export interface NormalizedRoutePoolConfig {
     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, {

package/dist/router/virtual-router/bootstrap/routing-config.js

@@ -91,7 +91,8 @@ export function expandRoutingTable(routingSource, aliasIndex, modelIndex) {
                     backup: pool.backup,
                     targets: sortedTargets,
                     ...(pool.mode ? { mode: pool.mode } : {}),
-                    ...(pool.force ? { force: true } : {})
+                    ...(pool.force ? { force: true } : {}),
+                    ...(pool.loadBalancing ? { loadBalancing: pool.loadBalancing } : {})
                 });
             }
         }
@@ -134,6 +135,7 @@ function normalizeRoutePoolEntry(routeName, entry, index, total) {
     const mode = normalizeRoutePoolMode(record.mode ?? record.strategy ?? record.routingMode);
     const force = record.force === true ||
         (typeof record.force === 'string' && record.force.trim().toLowerCase() === 'true');
+    const loadBalancing = normalizeRoutePoolLoadBalancing(record.loadBalancing);
     return targets.length
         ? {
             id,
@@ -141,10 +143,53 @@ function normalizeRoutePoolEntry(routeName, entry, index, total) {
             backup,
             targets,
             ...(mode ? { mode } : {}),
-            ...(force ? { force: true } : {})
+            ...(force ? { force: true } : {}),
+            ...(loadBalancing ? { loadBalancing } : {})
         }
         : null;
 }
+function normalizeRoutePoolLoadBalancing(input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input)) {
+        return undefined;
+    }
+    const record = input;
+    const strategy = normalizeWeightedStrategy(record.strategy);
+    const weightsRaw = record.weights && typeof record.weights === 'object' && !Array.isArray(record.weights)
+        ? record.weights
+        : {};
+    const weights = {};
+    for (const [key, value] of Object.entries(weightsRaw)) {
+        if (typeof value === 'number' && Number.isFinite(value) && value > 0) {
+            weights[key] = value;
+        }
+    }
+    if (!strategy && Object.keys(weights).length === 0) {
+        return undefined;
+    }
+    return {
+        ...(strategy ? { strategy } : {}),
+        ...(Object.keys(weights).length ? { weights } : {})
+    };
+}
+function normalizeWeightedStrategy(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (!normalized) {
+        return undefined;
+    }
+    if (normalized === 'weighted') {
+        return 'weighted';
+    }
+    if (normalized === 'sticky') {
+        return 'sticky';
+    }
+    if (normalized === 'round-robin' || normalized === 'round_robin' || normalized === 'roundrobin' || normalized === 'rr') {
+        return 'round-robin';
+    }
+    return undefined;
+}
 function normalizeRoutePoolMode(value) {
     if (typeof value !== 'string') {
         return undefined;

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

@@ -37,6 +37,27 @@ export function normalizeWebSearch(input, routingSource) {
         const resolvedProviderKey = resolveWebSearchEngineProviderKey(providerKey, webSearchRouteTargets) ?? providerKey;
         const description = typeof node.description === 'string' && node.description.trim() ? node.description.trim() : undefined;
         const isDefault = node.default === true || (typeof node.default === 'string' && node.default.trim().toLowerCase() === 'true');
+        const rawExecutionMode = typeof node.executionMode === 'string'
+            ? node.executionMode.trim().toLowerCase()
+            : typeof node.mode === 'string'
+                ? node.mode.trim().toLowerCase()
+                : '';
+        const executionMode = rawExecutionMode === 'direct' ? 'direct' : 'servertool';
+        const rawDirectActivation = typeof node.directActivation === 'string'
+            ? node.directActivation.trim().toLowerCase()
+            : typeof node.activation === 'string'
+                ? node.activation.trim().toLowerCase()
+                : '';
+        const directActivation = rawDirectActivation === 'builtin'
+            ? 'builtin'
+            : rawDirectActivation === 'route'
+                ? 'route'
+                : executionMode === 'direct'
+                    ? 'route'
+                    : undefined;
+        const modelId = typeof node.modelId === 'string' && node.modelId.trim() ? node.modelId.trim() : undefined;
+        const maxUsesRaw = typeof node.maxUses === 'number' ? node.maxUses : Number(node.maxUses);
+        const maxUses = Number.isFinite(maxUsesRaw) && maxUsesRaw > 0 ? Math.floor(maxUsesRaw) : undefined;
         const serverToolsDisabled = node.serverToolsDisabled === true ||
             (typeof node.serverToolsDisabled === 'string' &&
                 node.serverToolsDisabled.trim().toLowerCase() === 'true') ||
@@ -51,6 +72,10 @@ export function normalizeWebSearch(input, routingSource) {
             providerKey: resolvedProviderKey,
             description,
             default: isDefault,
+            executionMode,
+            ...(directActivation ? { directActivation } : {}),
+            ...(modelId ? { modelId } : {}),
+            ...(maxUses ? { maxUses } : {}),
             ...(serverToolsDisabled ? { serverToolsDisabled: true } : {})
         });
     }

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

@@ -140,26 +140,31 @@ function buildProviderRuntimeEntries(providers) {
     }
     return { runtimeEntries, aliasIndex, modelIndex };
 }
-function collectProviderModels(providerRaw, normalizedProvider) {
+function collectProviderModels(providerRaw, _normalizedProvider) {
     const rawModelsNode = providerRaw.models;
     const modelsDeclared = rawModelsNode !== undefined;
     const modelsNode = asRecord(rawModelsNode);
-    const baseModels = Object.keys(modelsNode).filter(Boolean);
-    if (normalizedProvider.compatibilityProfile !== 'chat:deepseek-web') {
-        return { declared: modelsDeclared, models: baseModels };
-    }
-    const withAliases = new Set(baseModels);
-    const hasChatBase = withAliases.has('deepseek-chat') || withAliases.has('deepseek-v3');
-    const hasReasonerBase = withAliases.has('deepseek-reasoner') || withAliases.has('deepseek-r1');
-    if (hasChatBase) {
-        withAliases.add('deepseek-chat-search');
-        withAliases.add('deepseek-v3-search');
-    }
-    if (hasReasonerBase) {
-        withAliases.add('deepseek-reasoner-search');
-        withAliases.add('deepseek-r1-search');
+    const collected = new Set();
+    for (const [modelName, modelConfigRaw] of Object.entries(modelsNode)) {
+        const normalizedModelName = typeof modelName === 'string' ? modelName.trim() : '';
+        if (normalizedModelName) {
+            collected.add(normalizedModelName);
+        }
+        const modelConfig = asRecord(modelConfigRaw);
+        const aliasesNode = Array.isArray(modelConfig.aliases)
+            ? modelConfig.aliases
+            : [];
+        for (const alias of aliasesNode) {
+            if (typeof alias !== 'string') {
+                continue;
+            }
+            const normalizedAlias = alias.trim();
+            if (normalizedAlias) {
+                collected.add(normalizedAlias);
+            }
+        }
     }
-    return { declared: modelsDeclared, models: Array.from(withAliases) };
+    return { declared: modelsDeclared, models: Array.from(collected) };
 }
 function normalizeClassifier(input) {
     const normalized = asRecord(input);

package/dist/router/virtual-router/engine-selection/native-compat-action-semantics.d.ts

@@ -0,0 +1,6 @@
+export declare function normalizeResponsePayloadWithNative(payload: Record<string, unknown>, config?: Record<string, unknown>): Record<string, unknown>;
+export declare function validateResponsePayloadWithNative(payload: Record<string, unknown>): void;
+export declare function applyRequestRulesWithNative(payload: Record<string, unknown>, config?: Record<string, unknown>): Record<string, unknown>;
+export declare function applyResponseBlacklistWithNative(payload: Record<string, unknown>, config?: Record<string, unknown>): Record<string, unknown>;
+export declare function normalizeToolCallIdsWithNative(payload: Record<string, unknown>): Record<string, unknown>;
+export declare function enforceLmstudioResponsesFcToolCallIdsWithNative(payload: Record<string, unknown>): Record<string, unknown>;

package/dist/router/virtual-router/engine-selection/native-compat-action-semantics.js

@@ -0,0 +1,171 @@
+import { failNativeRequired, isNativeDisabledByEnv } from './native-router-hotpath-policy.js';
+import { loadNativeRouterHotpathBindingForInternalUse } from './native-router-hotpath.js';
+function readNativeFunction(name) {
+    const binding = loadNativeRouterHotpathBindingForInternalUse();
+    const fn = binding?.[name];
+    return typeof fn === 'function' ? fn : null;
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseRecord(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export function normalizeResponsePayloadWithNative(payload, config) {
+    const capability = 'normalizeResponsePayloadJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify(payload);
+    const configJson = config ? safeStringify(config) : '{}';
+    if (!payloadJson || !configJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson, configJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseRecord(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function validateResponsePayloadWithNative(payload) {
+    const capability = 'validateResponsePayloadJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify(payload);
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        fn(payloadJson);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        throw new Error(reason);
+    }
+}
+export function applyRequestRulesWithNative(payload, config) {
+    const capability = 'applyRequestRulesJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv())
+        return fail('native disabled');
+    const fn = readNativeFunction(capability);
+    if (!fn)
+        return fail();
+    const payloadJson = safeStringify(payload);
+    const configJson = config ? safeStringify(config) : '{}';
+    if (!payloadJson || !configJson)
+        return fail('json stringify failed');
+    try {
+        const raw = fn(payloadJson, configJson);
+        if (typeof raw !== 'string' || !raw)
+            return fail('empty result');
+        const parsed = parseRecord(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function applyResponseBlacklistWithNative(payload, config) {
+    const capability = 'applyResponseBlacklistJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv())
+        return fail('native disabled');
+    const fn = readNativeFunction(capability);
+    if (!fn)
+        return fail();
+    const payloadJson = safeStringify(payload);
+    const configJson = config ? safeStringify(config) : '{}';
+    if (!payloadJson || !configJson)
+        return fail('json stringify failed');
+    try {
+        const raw = fn(payloadJson, configJson);
+        if (typeof raw !== 'string' || !raw)
+            return fail('empty result');
+        const parsed = parseRecord(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function normalizeToolCallIdsWithNative(payload) {
+    const capability = 'normalizeToolCallIdsJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv())
+        return fail('native disabled');
+    const fn = readNativeFunction(capability);
+    if (!fn)
+        return fail();
+    const payloadJson = safeStringify(payload);
+    if (!payloadJson)
+        return fail('json stringify failed');
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw)
+            return fail('empty result');
+        const parsed = parseRecord(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function enforceLmstudioResponsesFcToolCallIdsWithNative(payload) {
+    const capability = 'enforceLmstudioResponsesFcToolCallIdsJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv())
+        return fail('native disabled');
+    const fn = readNativeFunction(capability);
+    if (!fn)
+        return fail();
+    const payloadJson = safeStringify(payload);
+    if (!payloadJson)
+        return fail('json stringify failed');
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw)
+            return fail('empty result');
+        const parsed = parseRecord(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}

package/dist/router/virtual-router/engine-selection/native-router-hotpath-loader.js

@@ -98,6 +98,8 @@ const REQUIRED_NATIVE_EXPORTS = [
     'chatToolToBridgeDefinitionJson',
     'mapBridgeToolsToChatWithOptionsJson',
     'mapChatToolsToBridgeWithOptionsJson',
+    'collectToolCallsFromResponsesJson',
+    'resolveFinishReasonJson',
     'captureReqInboundResponsesContextSnapshotJson',
     'computeQuotaBucketsJson',
     'extractReasoningSegmentsJson',
@@ -167,6 +169,15 @@ const REQUIRED_NATIVE_EXPORTS = [
     'normalizeChatResponseReasoningToolsJson',
     'normalizeBridgeToolCallIdsJson',
     'normalizeChatMessageContentJson',
+    'validateResponsePayloadJson',
+    'normalizeResponsePayloadJson',
+    'applyResponseBlacklistJson',
+    'normalizeToolCallIdsJson',
+    'normalizeResponsesToolCallIdsJson',
+    'resolveToolCallIdStyleJson',
+    'stripInternalToolingMetadataJson',
+    'enforceLmstudioResponsesFcToolCallIdsJson',
+    'applyRequestRulesJson',
     'normalizeArgsBySchemaJson',
     'normalizeToolsJson',
     'normalizeFunctionCallIdJson',

package/dist/router/virtual-router/engine-selection/native-shared-conversion-semantics.d.ts

@@ -26,6 +26,8 @@ export declare function mapBridgeToolsToChatWithNative(rawTools: unknown, option
 export declare function mapChatToolsToBridgeWithNative(rawTools: unknown, options?: {
     sanitizeMode?: string;
 }): Array<Record<string, unknown>>;
+export declare function collectToolCallsFromResponsesWithNative(response: Record<string, unknown>): Array<Record<string, unknown>>;
+export declare function resolveFinishReasonWithNative(response: Record<string, unknown>, toolCalls: Array<Record<string, unknown>>): string;
 export declare function hasValidThoughtSignatureWithNative(block: unknown, options?: Record<string, unknown>): boolean;
 export declare function sanitizeThinkingBlockWithNative(block: unknown): Record<string, unknown>;
 export declare function filterInvalidThinkingBlocksWithNative(messages: unknown, options?: Record<string, unknown>): unknown[];
@@ -49,6 +51,9 @@ export declare function enforceToolCallIdStyleWithNative(messages: unknown[], st
     messages: unknown[];
     state: Record<string, unknown>;
 };
+export declare function normalizeResponsesToolCallIdsWithNative(payload: unknown): Record<string, unknown> | null;
+export declare function resolveToolCallIdStyleWithNative(metadata: unknown): string;
+export declare function stripInternalToolingMetadataWithNative(metadata: unknown): Record<string, unknown> | null;
 export declare function buildProviderProtocolErrorWithNative(input: {
     message: string;
     code: string;

package/dist/router/virtual-router/engine-selection/native-shared-conversion-semantics.js

@@ -123,6 +123,10 @@ function parseToolDefinitionArray(raw) {
     }
     return output;
 }
+function parseString(raw) {
+    const parsed = parseJson(raw);
+    return typeof parsed === 'string' ? parsed : null;
+}
 function parseStringArray(raw) {
     const parsed = parseArray(raw);
     if (!parsed)
@@ -510,6 +514,60 @@ export function mapChatToolsToBridgeWithNative(rawTools, options) {
         return fail(reason);
     }
 }
+export function collectToolCallsFromResponsesWithNative(response) {
+    const capability = 'collectToolCallsFromResponsesJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify(response ?? {});
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseToolDefinitionArray(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function resolveFinishReasonWithNative(response, toolCalls) {
+    const capability = 'resolveFinishReasonJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const responseJson = safeStringify(response ?? {});
+    const toolCallsJson = safeStringify(Array.isArray(toolCalls) ? toolCalls : []);
+    if (!responseJson || !toolCallsJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(responseJson, toolCallsJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        return parseString(raw) ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
 export function hasValidThoughtSignatureWithNative(block, options) {
     const capability = 'hasValidThoughtSignatureJson';
     const fail = (reason) => failNativeRequired(capability, reason);
@@ -973,6 +1031,85 @@ export function enforceToolCallIdStyleWithNative(messages, state) {
         return fail(reason);
     }
 }
+export function normalizeResponsesToolCallIdsWithNative(payload) {
+    const capability = 'normalizeResponsesToolCallIdsJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify(payload ?? null);
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        return parseRecord(raw) ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function resolveToolCallIdStyleWithNative(metadata) {
+    const capability = 'resolveToolCallIdStyleJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const metadataJson = safeStringify(metadata ?? null);
+    if (!metadataJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(metadataJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseJson(raw);
+        return typeof parsed === 'string' ? parsed : fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function stripInternalToolingMetadataWithNative(metadata) {
+    const capability = 'stripInternalToolingMetadataJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const metadataJson = safeStringify(metadata ?? null);
+    if (!metadataJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(metadataJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        return parseRecord(raw) ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
 export function buildProviderProtocolErrorWithNative(input) {
     const capability = 'buildProviderProtocolErrorJson';
     const fail = (reason) => failNativeRequired(capability, reason);

package/dist/router/virtual-router/engine-selection/tier-load-balancing.d.ts

@@ -0,0 +1,16 @@
+import type { LoadBalancingPolicy, RoutePoolTier } from '../types.js';
+import type { ProviderRegistry } from '../provider-registry.js';
+export type ResolvedTierLoadBalancing = {
+    strategy: LoadBalancingPolicy['strategy'];
+    weights?: Record<string, number>;
+};
+export declare function resolveTierLoadBalancing(tier: RoutePoolTier, globalPolicy?: LoadBalancingPolicy): ResolvedTierLoadBalancing;
+export declare function resolveGroupWeight(groupId: string, weights?: Record<string, number>): number;
+export declare function buildGroupWeights(groups: Map<string, string[]>, weights?: Record<string, number>): Record<string, number> | undefined;
+export declare function hasNonUniformWeights(candidates: string[], weights?: Record<string, number>): boolean;
+export declare function buildCandidateWeights(opts: {
+    candidates: string[];
+    providerRegistry: ProviderRegistry;
+    staticWeights?: Record<string, number>;
+    dynamicWeights?: Record<string, number>;
+}): Record<string, number> | undefined;