@jsonstudio/llms 0.6.3405 → 0.6.3539

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

@@ -28,6 +28,7 @@ export declare function mapChatToolsToBridgeWithNative(rawTools: unknown, option
 }): 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 buildChatResponseFromResponsesWithNative(payload: unknown): Record<string, unknown> | null;
 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[];
@@ -146,6 +147,16 @@ export declare function extractStreamingToolCallsWithNative(input: {
     idCounter: number;
     toolCalls: Array<Record<string, unknown>>;
 };
+export declare function createStreamingToolExtractorStateWithNative(idPrefix?: string): Record<string, unknown>;
+export declare function resetStreamingToolExtractorStateWithNative(state: Record<string, unknown>): Record<string, unknown>;
+export declare function feedStreamingToolExtractorWithNative(input: {
+    state: Record<string, unknown>;
+    text: string;
+    nowMs?: number;
+}): {
+    state: Record<string, unknown>;
+    toolCalls: Array<Record<string, unknown>>;
+};
 export declare function isCompactionRequestWithNative(payload: unknown): boolean;
 export declare function encodeMetadataPassthroughWithNative(parameters: unknown, prefix: string, keys: readonly string[]): Record<string, string> | undefined;
 export declare function extractMetadataPassthroughWithNative(metadataField: unknown, prefix: string, keys: readonly string[]): {
@@ -194,6 +205,15 @@ export declare function prepareGeminiToolsForBridgeWithNative(rawTools: unknown,
 export declare function buildGeminiToolsFromBridgeWithNative(defs: unknown, mode?: 'antigravity' | 'default'): Array<Record<string, unknown>> | undefined;
 export declare function pickResponsesPersistedFieldsWithNative(payload: unknown): Record<string, unknown>;
 export declare function convertResponsesOutputToInputItemsWithNative(response: unknown): Array<Record<string, unknown>>;
+export declare function prepareResponsesConversationEntryWithNative(payload: unknown, context: unknown): {
+    basePayload: Record<string, unknown>;
+    input: Array<Record<string, unknown>>;
+    tools?: Array<Record<string, unknown>>;
+};
+export declare function resumeResponsesConversationPayloadWithNative(entry: unknown, responseId: string, submitPayload: unknown, requestId?: string): {
+    payload: Record<string, unknown>;
+    meta: Record<string, unknown>;
+};
 export declare function enforceChatBudgetWithNative(chat: unknown, allowedBytes: number, systemTextLimit: number): unknown;
 export declare function resolveBudgetForModelWithNative(modelId: string, fallback: {
     maxBytes: number;

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

@@ -111,6 +111,24 @@ function parseToolDefinitionOutput(raw) {
     const parsed = parseRecord(raw);
     return parsed;
 }
+function parseResponsesConversationResumeResult(raw) {
+    const parsed = parseRecord(raw);
+    if (!parsed) {
+        return null;
+    }
+    const payload = parsed.payload;
+    const meta = parsed.meta;
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        return null;
+    }
+    if (!meta || typeof meta !== 'object' || Array.isArray(meta)) {
+        return null;
+    }
+    return {
+        payload: payload,
+        meta: meta
+    };
+}
 function parseToolDefinitionArray(raw) {
     const parsed = parseArray(raw);
     if (!parsed)
@@ -568,6 +586,32 @@ export function resolveFinishReasonWithNative(response, toolCalls) {
         return fail(reason);
     }
 }
+export function buildChatResponseFromResponsesWithNative(payload) {
+    const capability = 'buildChatResponseFromResponsesJson';
+    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 hasValidThoughtSignatureWithNative(block, options) {
     const capability = 'hasValidThoughtSignatureJson';
     const fail = (reason) => failNativeRequired(capability, reason);
@@ -1414,6 +1458,92 @@ export function extractStreamingToolCallsWithNative(input) {
         return fail(reason);
     }
 }
+export function createStreamingToolExtractorStateWithNative(idPrefix) {
+    const capability = 'createStreamingToolExtractorStateJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify(idPrefix ? { idPrefix } : {});
+    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 resetStreamingToolExtractorStateWithNative(state) {
+    const capability = 'resetStreamingToolExtractorStateJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify(state ?? {});
+    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 feedStreamingToolExtractorWithNative(input) {
+    const capability = 'feedStreamingToolExtractorJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify(input ?? {});
+    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);
+        if (!parsed || !parsed.state || typeof parsed.state !== 'object' || Array.isArray(parsed.state)) {
+            return fail('invalid payload');
+        }
+        const toolCalls = Array.isArray(parsed.toolCalls)
+            ? parsed.toolCalls.filter((entry) => entry && typeof entry === 'object' && !Array.isArray(entry))
+                .map((entry) => entry)
+            : [];
+        return { state: parsed.state, toolCalls };
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
 export function isCompactionRequestWithNative(payload) {
     const capability = 'isCompactionRequestJson';
     const fail = (reason) => failNativeRequired(capability, reason);
@@ -2177,6 +2307,77 @@ export function convertResponsesOutputToInputItemsWithNative(response) {
         return fail(reason);
     }
 }
+export function prepareResponsesConversationEntryWithNative(payload, context) {
+    const capability = 'prepareResponsesConversationEntryJson';
+    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);
+    const contextJson = safeStringify(context ?? null);
+    if (!payloadJson || !contextJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson, contextJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseRecord(raw);
+        if (!parsed) {
+            return fail('invalid payload');
+        }
+        const basePayload = parsed.basePayload;
+        const input = parsed.input;
+        const tools = parsed.tools;
+        if (!basePayload || typeof basePayload !== 'object' || Array.isArray(basePayload) || !Array.isArray(input)) {
+            return fail('invalid payload');
+        }
+        return {
+            basePayload: basePayload,
+            input: input.filter((entry) => !!entry && typeof entry === 'object' && !Array.isArray(entry)),
+            tools: Array.isArray(tools)
+                ? tools.filter((entry) => !!entry && typeof entry === 'object' && !Array.isArray(entry))
+                : undefined
+        };
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function resumeResponsesConversationPayloadWithNative(entry, responseId, submitPayload, requestId) {
+    const capability = 'resumeResponsesConversationPayloadJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const entryJson = safeStringify(entry ?? null);
+    const submitPayloadJson = safeStringify(submitPayload ?? null);
+    if (!entryJson || !submitPayloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(entryJson, String(responseId ?? ''), submitPayloadJson, requestId);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseResponsesConversationResumeResult(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
 export function enforceChatBudgetWithNative(chat, allowedBytes, systemTextLimit) {
     const capability = 'enforceChatBudgetJson';
     const fail = (reason) => failNativeRequired(capability, reason);

package/dist/router/virtual-router/engine-selection/native-virtual-router-routing-instructions-semantics.d.ts

@@ -1,2 +1,3 @@
 export declare function parseRoutingInstructionKindsWithNative(request: unknown): string[];
+export declare function parseRoutingInstructionsWithNative(messages: Array<Record<string, unknown>>): Array<Record<string, unknown>>;
 export declare function cleanRoutingInstructionMarkersWithNative(request: Record<string, unknown>): Record<string, unknown>;

package/dist/router/virtual-router/engine-selection/native-virtual-router-routing-instructions-semantics.js

@@ -36,6 +36,19 @@ function parseRecordPayload(raw) {
         return null;
     }
 }
+function parseRecordArrayPayload(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed)) {
+            return null;
+        }
+        const records = parsed.filter((entry) => entry && typeof entry === 'object' && !Array.isArray(entry));
+        return records.length === parsed.length ? records : null;
+    }
+    catch {
+        return null;
+    }
+}
 export function parseRoutingInstructionKindsWithNative(request) {
     const capability = 'parseRoutingInstructionKindsJson';
     const fail = (reason) => failNativeRequired(capability, reason);
@@ -60,6 +73,30 @@ export function parseRoutingInstructionKindsWithNative(request) {
         return fail(reason);
     }
 }
+export function parseRoutingInstructionsWithNative(messages) {
+    const capability = 'parseRoutingInstructionsJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const messagesJson = safeStringify(messages);
+    if (!messagesJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const result = fn(messagesJson);
+        if (typeof result !== 'string' || !result) {
+            return fail('empty result');
+        }
+        const parsed = parseRecordArrayPayload(result);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
 export function cleanRoutingInstructionMarkersWithNative(request) {
     const capability = 'cleanRoutingInstructionMarkersJson';
     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;

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;
         }