@jsonstudio/llms 0.6.3405 → 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/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;

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

@@ -0,0 +1,120 @@
+import { extractProviderId, getProviderModelId } from './key-parsing.js';
+export function resolveTierLoadBalancing(tier, globalPolicy) {
+    const tierPolicy = tier.loadBalancing;
+    return {
+        strategy: tierPolicy?.strategy ?? globalPolicy?.strategy ?? 'round-robin',
+        weights: tierPolicy?.weights ?? globalPolicy?.weights
+    };
+}
+export function resolveGroupWeight(groupId, weights) {
+    if (!weights) {
+        return 1;
+    }
+    const direct = weights[groupId];
+    if (typeof direct === 'number' && Number.isFinite(direct) && direct > 0) {
+        return direct;
+    }
+    const providerId = groupId.split('.')[0] ?? groupId;
+    const providerOnly = weights[providerId];
+    if (typeof providerOnly === 'number' && Number.isFinite(providerOnly) && providerOnly > 0) {
+        return providerOnly;
+    }
+    return 1;
+}
+export function buildGroupWeights(groups, weights) {
+    if (!groups.size || !weights) {
+        return undefined;
+    }
+    const out = {};
+    let hasExplicit = false;
+    for (const [groupId] of groups.entries()) {
+        const resolved = resolveGroupWeight(groupId, weights);
+        out[groupId] = resolved;
+        if (resolved !== 1) {
+            hasExplicit = true;
+        }
+    }
+    return hasExplicit ? out : undefined;
+}
+export function hasNonUniformWeights(candidates, weights) {
+    if (!weights || candidates.length < 2) {
+        return false;
+    }
+    let ref;
+    for (const key of candidates) {
+        const raw = weights[key];
+        if (typeof raw !== 'number' || !Number.isFinite(raw)) {
+            continue;
+        }
+        if (ref === undefined) {
+            ref = raw;
+        }
+        else if (Math.abs(raw - ref) > 1e-6) {
+            return true;
+        }
+    }
+    return false;
+}
+export function buildCandidateWeights(opts) {
+    const { candidates, providerRegistry, staticWeights, dynamicWeights } = opts;
+    if ((!staticWeights || Object.keys(staticWeights).length === 0) && (!dynamicWeights || Object.keys(dynamicWeights).length === 0)) {
+        return undefined;
+    }
+    const out = {};
+    let hasExplicit = false;
+    for (const key of candidates) {
+        const dynamic = dynamicWeights?.[key];
+        const staticWeight = resolveCandidateWeight(key, staticWeights, providerRegistry);
+        const resolved = multiplyPositiveWeights(dynamic, staticWeight);
+        if (resolved !== undefined) {
+            out[key] = resolved;
+            if (resolved !== 1) {
+                hasExplicit = true;
+            }
+        }
+    }
+    if (!hasExplicit) {
+        return undefined;
+    }
+    return out;
+}
+function resolveCandidateWeight(key, weights, providerRegistry) {
+    if (!weights) {
+        return undefined;
+    }
+    const direct = normalizePositiveWeight(weights[key]);
+    if (direct !== undefined) {
+        return direct;
+    }
+    const providerId = extractProviderId(key) ?? '';
+    if (!providerId) {
+        return undefined;
+    }
+    try {
+        const modelId = getProviderModelId(key, providerRegistry) ?? '';
+        if (modelId) {
+            const grouped = normalizePositiveWeight(weights[`${providerId}.${modelId}`]);
+            if (grouped !== undefined) {
+                return grouped;
+            }
+        }
+    }
+    catch {
+        // Ignore registry misses and fall back to provider-only weight.
+    }
+    return normalizePositiveWeight(weights[providerId]);
+}
+function normalizePositiveWeight(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : undefined;
+}
+function multiplyPositiveWeights(...values) {
+    let resolved;
+    for (const value of values) {
+        const normalized = normalizePositiveWeight(value);
+        if (normalized === undefined) {
+            continue;
+        }
+        resolved = resolved === undefined ? normalized : Math.max(1, Math.round(resolved * normalized));
+    }
+    return resolved;
+}

package/dist/router/virtual-router/engine-selection/tier-selection-quota-integration.d.ts

@@ -3,6 +3,7 @@ import { type ResolvedContextWeightedConfig } from '../context-weighted.js';
 import { type ResolvedHealthWeightedConfig } from '../health-weighted.js';
 import type { RoutePoolTier } from '../types.js';
 import type { SelectionDeps, TrySelectFromTierOptions } from './selection-deps.js';
+import { type ResolvedTierLoadBalancing } from './tier-load-balancing.js';
 export declare function selectProviderKeyWithQuotaBuckets(opts: {
     routeName: string;
     tier: RoutePoolTier;
@@ -19,6 +20,7 @@ export declare function selectProviderKeyWithQuotaBuckets(opts: {
     nowForWeights: number;
     healthWeightedCfg: ResolvedHealthWeightedConfig;
     contextWeightedCfg: ResolvedContextWeightedConfig;
+    tierLoadBalancing: ResolvedTierLoadBalancing;
     quotaView: NonNullable<SelectionDeps['quotaView']>;
     isAvailable: (key: string) => boolean;
     selectFirstAvailable: (keys: string[]) => string | null;

package/dist/router/virtual-router/engine-selection/tier-selection-quota-integration.js

@@ -2,6 +2,7 @@ import { computeContextMultiplier } from '../context-weighted.js';
 import { computeHealthWeight } from '../health-weighted.js';
 import { buildQuotaBuckets } from './native-router-hotpath.js';
 import { computeContextWeightMultipliers } from './context-weight-multipliers.js';
+import { buildCandidateWeights, buildGroupWeights, hasNonUniformWeights } from './tier-load-balancing.js';
 import { pickPriorityGroup } from './tier-priority.js';
 import { extractProviderId, getProviderModelId } from './key-parsing.js';
 function buildPrimaryTargetGroups(candidates, deps) {
@@ -25,52 +26,8 @@ function buildPrimaryTargetGroups(candidates, deps) {
     }
     return groups;
 }
-function resolveGroupWeight(groupId, weights) {
-    if (!weights) {
-        return 1;
-    }
-    const direct = weights[groupId];
-    if (typeof direct === 'number' && Number.isFinite(direct) && direct > 0) {
-        return direct;
-    }
-    const providerId = groupId.split('.')[0] ?? groupId;
-    const providerOnly = weights[providerId];
-    if (typeof providerOnly === 'number' && Number.isFinite(providerOnly) && providerOnly > 0) {
-        return providerOnly;
-    }
-    return 1;
-}
-function buildGroupWeights(groups, weights) {
-    if (!groups.size) {
-        return undefined;
-    }
-    const out = {};
-    for (const [groupId] of groups.entries()) {
-        out[groupId] = resolveGroupWeight(groupId, weights);
-    }
-    return out;
-}
-function hasNonUniformWeights(candidates, weights) {
-    if (!weights || candidates.length < 2) {
-        return false;
-    }
-    let ref;
-    for (const key of candidates) {
-        const raw = weights[key];
-        if (typeof raw !== 'number' || !Number.isFinite(raw)) {
-            continue;
-        }
-        if (ref === undefined) {
-            ref = raw;
-        }
-        else if (Math.abs(raw - ref) > 1e-6) {
-            return true;
-        }
-    }
-    return false;
-}
 export function selectProviderKeyWithQuotaBuckets(opts) {
-    const { routeName, tier, stickyKey, candidates, isSafePool, deps, options, contextResult, warnRatio, isRecoveryAttempt, now, nowForWeights, healthWeightedCfg, contextWeightedCfg, quotaView, isAvailable, selectFirstAvailable, applyAliasStickyQueuePinning, preferAntigravityAliasesOnRetry } = opts;
+    const { routeName, tier, stickyKey, candidates, isSafePool, deps, options, contextResult, warnRatio, isRecoveryAttempt, now, nowForWeights, healthWeightedCfg, contextWeightedCfg, tierLoadBalancing, quotaView, isAvailable, selectFirstAvailable, applyAliasStickyQueuePinning, preferAntigravityAliasesOnRetry } = opts;
     const bucketInputs = candidates.map((key, order) => {
         const entry = quotaView(key);
         const penaltyRaw = entry?.selectionPenalty;
@@ -100,35 +57,56 @@ export function selectProviderKeyWithQuotaBuckets(opts) {
             bucketCandidates = preferAntigravityAliasesOnRetry(bucketCandidates);
         }
         bucketCandidates = applyAliasStickyQueuePinning(bucketCandidates);
-        const bucketWeights = {};
+        const quotaWeights = {};
         for (const item of bucket) {
             if (healthWeightedCfg.enabled) {
                 const entry = quotaView(item.key);
                 const { weight } = computeHealthWeight(entry, nowForWeights, healthWeightedCfg);
-                bucketWeights[item.key] = weight;
+                quotaWeights[item.key] = weight;
             }
             else {
-                bucketWeights[item.key] = Math.max(1, Math.floor(100 / (1 + Math.max(0, item.penalty))));
+                quotaWeights[item.key] = Math.max(1, Math.floor(100 / (1 + Math.max(0, item.penalty))));
             }
         }
-        if (isSafePool && contextWeightedCfg.enabled) {
+        const contextWeights = (() => {
+            if (!isSafePool || !contextWeightedCfg.enabled) {
+                return undefined;
+            }
             const ctx = computeContextWeightMultipliers({
                 candidates: bucketCandidates,
                 usage: contextResult.usage,
                 warnRatio,
                 cfg: contextWeightedCfg
             });
-            if (ctx) {
-                for (const key of bucketCandidates) {
-                    const m = computeContextMultiplier({
-                        effectiveSafeRefTokens: ctx.ref,
-                        effectiveSafeTokens: ctx.eff[key] ?? 1,
-                        cfg: contextWeightedCfg
-                    });
-                    bucketWeights[key] = Math.max(1, Math.round((bucketWeights[key] ?? 1) * m));
-                }
+            if (!ctx) {
+                return undefined;
             }
-        }
+            const out = {};
+            for (const key of bucketCandidates) {
+                const m = computeContextMultiplier({
+                    effectiveSafeRefTokens: ctx.ref,
+                    effectiveSafeTokens: ctx.eff[key] ?? 1,
+                    cfg: contextWeightedCfg
+                });
+                out[key] = Math.max(1, Math.round(100 * m));
+            }
+            return out;
+        })();
+        const bucketWeights = buildCandidateWeights({
+            candidates: bucketCandidates,
+            providerRegistry: deps.providerRegistry,
+            staticWeights: tierLoadBalancing.weights,
+            dynamicWeights: Object.keys(quotaWeights).length || contextWeights
+                ? Object.fromEntries(bucketCandidates.map((key) => {
+                    const quotaWeight = quotaWeights[key];
+                    const contextWeight = contextWeights?.[key];
+                    const combined = typeof contextWeight === 'number'
+                        ? Math.max(1, Math.round((quotaWeight ?? 1) * contextWeight))
+                        : quotaWeight;
+                    return [key, combined ?? 1];
+                }))
+                : undefined
+        });
         if (tier.mode === 'priority') {
             if (!isRecoveryAttempt) {
                 const group = pickPriorityGroup({
@@ -142,13 +120,13 @@ export function selectProviderKeyWithQuotaBuckets(opts) {
                 }
                 const groupWeights = {};
                 for (const key of group.groupCandidates) {
-                    groupWeights[key] = bucketWeights[key] ?? 1;
+                    groupWeights[key] = bucketWeights?.[key] ?? 1;
                 }
                 const allowGrouped = !hasNonUniformWeights(group.groupCandidates, bucketWeights);
-                if (allowGrouped && deps.loadBalancer.getPolicy().strategy !== 'sticky') {
+                if (allowGrouped && tierLoadBalancing.strategy !== 'sticky') {
                     const groups = buildPrimaryTargetGroups(group.groupCandidates, deps);
                     if (groups.size > 0) {
-                        const groupWeightMap = buildGroupWeights(groups, deps.loadBalancer.getPolicy().weights);
+                        const groupWeightMap = buildGroupWeights(groups, tierLoadBalancing.weights);
                         const selected = deps.loadBalancer.selectGrouped({
                             routeName: `${routeName}:${tier.id}:priority:${priority}:group:${group.groupId}`,
                             groups,
@@ -185,17 +163,17 @@ export function selectProviderKeyWithQuotaBuckets(opts) {
             continue;
         }
         const allowGrouped = !hasNonUniformWeights(bucketCandidates, bucketWeights);
-        if (allowGrouped && deps.loadBalancer.getPolicy().strategy !== 'sticky') {
+        if (allowGrouped && tierLoadBalancing.strategy !== 'sticky') {
             const groups = buildPrimaryTargetGroups(bucketCandidates, deps);
             if (groups.size > 0) {
-                const groupWeightMap = buildGroupWeights(groups, deps.loadBalancer.getPolicy().weights);
+                const groupWeightMap = buildGroupWeights(groups, tierLoadBalancing.weights);
                 const selected = deps.loadBalancer.selectGrouped({
                     routeName: `${routeName}:${tier.id}:${priority}`,
                     groups,
                     stickyKey: options.allowAliasRotation ? undefined : stickyKey,
                     weights: groupWeightMap,
                     availabilityCheck: isAvailable
-                }, tier.mode === 'round-robin' ? 'round-robin' : undefined);
+                }, tier.mode === 'round-robin' ? 'round-robin' : tierLoadBalancing.strategy);
                 if (selected) {
                     return selected;
                 }
@@ -207,7 +185,7 @@ export function selectProviderKeyWithQuotaBuckets(opts) {
             stickyKey: options.allowAliasRotation ? undefined : stickyKey,
             weights: bucketWeights,
             availabilityCheck: isAvailable
-        }, tier.mode === 'round-robin' ? 'round-robin' : undefined);
+        }, tier.mode === 'round-robin' ? 'round-robin' : tierLoadBalancing.strategy);
         if (selected) {
             return selected;
         }

package/dist/router/virtual-router/engine-selection/tier-selection-select.js

@@ -2,6 +2,7 @@ import { computeContextMultiplier } from '../context-weighted.js';
 import { pinCandidatesByAliasQueue, resolveAliasSelectionStrategy } from './alias-selection.js';
 import { computeContextWeightMultipliers } from './context-weight-multipliers.js';
 import { extractKeyAlias, extractProviderId, getProviderModelId } from './key-parsing.js';
+import { buildCandidateWeights, buildGroupWeights, hasNonUniformWeights, resolveTierLoadBalancing } from './tier-load-balancing.js';
 import { pickPriorityGroup } from './tier-priority.js';
 import { selectProviderKeyWithQuotaBuckets } from './tier-selection-quota-integration.js';
 function buildPrimaryTargetGroups(candidates, deps) {
@@ -25,50 +26,6 @@ function buildPrimaryTargetGroups(candidates, deps) {
     }
     return groups;
 }
-function resolveGroupWeight(groupId, weights) {
-    if (!weights) {
-        return 1;
-    }
-    const direct = weights[groupId];
-    if (typeof direct === 'number' && Number.isFinite(direct) && direct > 0) {
-        return direct;
-    }
-    const providerId = groupId.split('.')[0] ?? groupId;
-    const providerOnly = weights[providerId];
-    if (typeof providerOnly === 'number' && Number.isFinite(providerOnly) && providerOnly > 0) {
-        return providerOnly;
-    }
-    return 1;
-}
-function buildGroupWeights(groups, weights) {
-    if (!groups.size) {
-        return undefined;
-    }
-    const out = {};
-    for (const [groupId] of groups.entries()) {
-        out[groupId] = resolveGroupWeight(groupId, weights);
-    }
-    return out;
-}
-function hasNonUniformWeights(candidates, weights) {
-    if (!weights || candidates.length < 2) {
-        return false;
-    }
-    let ref;
-    for (const key of candidates) {
-        const raw = weights[key];
-        if (typeof raw !== 'number' || !Number.isFinite(raw)) {
-            continue;
-        }
-        if (ref === undefined) {
-            ref = raw;
-        }
-        else if (Math.abs(raw - ref) > 1e-6) {
-            return true;
-        }
-    }
-    return false;
-}
 function applyAliasStickyQueuePinning(opts) {
     const { candidates, orderedTargets, deps, excludedKeys } = opts;
     if (!Array.isArray(candidates) || candidates.length < 2) {
@@ -202,6 +159,7 @@ function preferAntigravityAliasesOnRetry(opts) {
 export function selectProviderKeyFromCandidatePool(opts) {
     const { routeName, tier, stickyKey, candidates, isSafePool, deps, options, contextResult, warnRatio, excludedKeys, isRecoveryAttempt, now, nowForWeights, healthWeightedCfg, contextWeightedCfg } = opts;
     const quotaView = deps.quotaView;
+    const tierLoadBalancing = resolveTierLoadBalancing(tier, deps.loadBalancer.getPolicy());
     const isAvailable = (key) => {
         if (!quotaView) {
             return deps.healthManager.isAvailable(key);
@@ -265,28 +223,33 @@ export function selectProviderKeyFromCandidatePool(opts) {
             if (!group) {
                 return null;
             }
-            const weights = (() => {
-                if (!isSafePool)
-                    return undefined;
-                const ctx = computeContextWeightMultipliers({ candidates: group.groupCandidates, usage: contextResult.usage, warnRatio, cfg: contextWeightedCfg });
-                if (!ctx)
-                    return undefined;
-                const out = {};
-                for (const key of group.groupCandidates) {
-                    const m = computeContextMultiplier({
-                        effectiveSafeRefTokens: ctx.ref,
-                        effectiveSafeTokens: ctx.eff[key] ?? 1,
-                        cfg: contextWeightedCfg
-                    });
-                    out[key] = Math.max(1, Math.round(100 * m));
-                }
-                return out;
-            })();
+            const weights = buildCandidateWeights({
+                candidates: group.groupCandidates,
+                providerRegistry: deps.providerRegistry,
+                staticWeights: tierLoadBalancing.weights,
+                dynamicWeights: (() => {
+                    if (!isSafePool)
+                        return undefined;
+                    const ctx = computeContextWeightMultipliers({ candidates: group.groupCandidates, usage: contextResult.usage, warnRatio, cfg: contextWeightedCfg });
+                    if (!ctx)
+                        return undefined;
+                    const out = {};
+                    for (const key of group.groupCandidates) {
+                        const m = computeContextMultiplier({
+                            effectiveSafeRefTokens: ctx.ref,
+                            effectiveSafeTokens: ctx.eff[key] ?? 1,
+                            cfg: contextWeightedCfg
+                        });
+                        out[key] = Math.max(1, Math.round(100 * m));
+                    }
+                    return out;
+                })()
+            });
             const allowGrouped = !hasNonUniformWeights(group.groupCandidates, weights);
-            if (allowGrouped && deps.loadBalancer.getPolicy().strategy !== 'sticky') {
+            if (allowGrouped && tierLoadBalancing.strategy !== 'sticky') {
                 const groups = buildPrimaryTargetGroups(group.groupCandidates, deps);
                 if (groups.size > 0) {
-                    const groupWeights = buildGroupWeights(groups, deps.loadBalancer.getPolicy().weights);
+                    const groupWeights = buildGroupWeights(groups, tierLoadBalancing.weights);
                     const selected = deps.loadBalancer.selectGrouped({
                         routeName: `${routeName}:${tier.id}:priority:group:${group.groupId}`,
                         groups,
@@ -307,35 +270,40 @@ export function selectProviderKeyFromCandidatePool(opts) {
                 availabilityCheck: isAvailable
             }, 'round-robin');
         }
-        const weights = (() => {
-            if (!isSafePool || !contextWeightedCfg.enabled)
-                return undefined;
-            const ctx = computeContextWeightMultipliers({ candidates: pinnedCandidates, usage: contextResult.usage, warnRatio, cfg: contextWeightedCfg });
-            if (!ctx)
-                return undefined;
-            const out = {};
-            for (const key of pinnedCandidates) {
-                const m = computeContextMultiplier({
-                    effectiveSafeRefTokens: ctx.ref,
-                    effectiveSafeTokens: ctx.eff[key] ?? 1,
-                    cfg: contextWeightedCfg
-                });
-                out[key] = Math.max(1, Math.round(100 * m));
-            }
-            return out;
-        })();
+        const weights = buildCandidateWeights({
+            candidates: pinnedCandidates,
+            providerRegistry: deps.providerRegistry,
+            staticWeights: tierLoadBalancing.weights,
+            dynamicWeights: (() => {
+                if (!isSafePool || !contextWeightedCfg.enabled)
+                    return undefined;
+                const ctx = computeContextWeightMultipliers({ candidates: pinnedCandidates, usage: contextResult.usage, warnRatio, cfg: contextWeightedCfg });
+                if (!ctx)
+                    return undefined;
+                const out = {};
+                for (const key of pinnedCandidates) {
+                    const m = computeContextMultiplier({
+                        effectiveSafeRefTokens: ctx.ref,
+                        effectiveSafeTokens: ctx.eff[key] ?? 1,
+                        cfg: contextWeightedCfg
+                    });
+                    out[key] = Math.max(1, Math.round(100 * m));
+                }
+                return out;
+            })()
+        });
         const allowGrouped = !hasNonUniformWeights(pinnedCandidates, weights);
-        if (allowGrouped && deps.loadBalancer.getPolicy().strategy !== 'sticky') {
+        if (allowGrouped && tierLoadBalancing.strategy !== 'sticky') {
             const groups = buildPrimaryTargetGroups(pinnedCandidates, deps);
             if (groups.size > 0) {
-                const groupWeights = buildGroupWeights(groups, deps.loadBalancer.getPolicy().weights);
+                const groupWeights = buildGroupWeights(groups, tierLoadBalancing.weights);
                 const selected = deps.loadBalancer.selectGrouped({
                     routeName: `${routeName}:${tier.id}`,
                     groups,
                     stickyKey: options.allowAliasRotation ? undefined : stickyKey,
                     weights: groupWeights,
                     availabilityCheck: isAvailable
-                }, tier.mode === 'round-robin' ? 'round-robin' : undefined);
+                }, tier.mode === 'round-robin' ? 'round-robin' : tierLoadBalancing.strategy);
                 if (selected) {
                     return selected;
                 }
@@ -347,7 +315,7 @@ export function selectProviderKeyFromCandidatePool(opts) {
             stickyKey: options.allowAliasRotation ? undefined : stickyKey,
             weights,
             availabilityCheck: isAvailable
-        }, tier.mode === 'round-robin' ? 'round-robin' : undefined);
+        }, tier.mode === 'round-robin' ? 'round-robin' : tierLoadBalancing.strategy);
     }
     return selectProviderKeyWithQuotaBuckets({
         routeName,
@@ -365,6 +333,7 @@ export function selectProviderKeyFromCandidatePool(opts) {
         nowForWeights,
         healthWeightedCfg,
         contextWeightedCfg,
+        tierLoadBalancing,
         quotaView,
         isAvailable,
         selectFirstAvailable,

package/dist/router/virtual-router/types.d.ts

@@ -7,6 +7,17 @@ export declare const DEFAULT_ROUTE = "default";
 export declare const ROUTE_PRIORITY: string[];
 export type RoutingInstructionMode = 'force' | 'sticky' | 'none';
 export type RoutePoolMode = 'round-robin' | 'priority';
+export interface RoutePoolLoadBalancingPolicy {
+    /**
+     * Optional pool-level override for provider selection strategy.
+     * When omitted, Virtual Router falls back to the global loadBalancing.strategy.
+     */
+    strategy?: 'round-robin' | 'weighted' | 'sticky';
+    /**
+     * Optional pool-local weights. Keys may target runtime keys, provider.model groups, or provider ids.
+     */
+    weights?: Record<string, number>;
+}
 export interface RoutePoolTier {
     id: string;
     targets: string[];
@@ -25,6 +36,11 @@ export interface RoutePoolTier {
      * - routing.web_search: force server-side web_search flow.
      */
     force?: boolean;
+    /**
+     * Optional pool-scoped load-balancing override. This lets different route pools
+     * use different strategies/weights without mutating the global policy.
+     */
+    loadBalancing?: RoutePoolLoadBalancingPolicy;
 }
 export type RoutingPools = Record<string, RoutePoolTier[]>;
 export type StreamingPreference = 'auto' | 'always' | 'never';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsonstudio/llms",
-  "version": "0.6.3405",
+  "version": "0.6.3409",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",