@jsonstudio/llms 0.6.3405 → 0.6.3539

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/engine.js

@@ -1,9 +1,6 @@
 import { VirtualRouterError, VirtualRouterErrorCode } from './types.js';
-import { ROUTING_INSTRUCTION_MARKER_PATTERN } from './routing-instructions/types.js';
-import { parseRoutingInstructions } from './routing-instructions/parse.js';
 import { createVirtualRouterEngineProxy } from './engine-selection/native-virtual-router-engine-proxy.js';
 import { cleanRoutingInstructionMarkersWithNative, parseRoutingInstructionKindsWithNative } from './engine-selection/native-virtual-router-routing-instructions-semantics.js';
-import { getLatestUserTextFromResponsesContext, hasLatestUserRoutingInstructionMarker, hasRoutingInstructionMarkerInResponsesContext } from './engine-legacy/helpers.js';
 import { extractMessageText, getLatestUserMessage } from './message-utils.js';
 import { ProviderRegistry } from './provider-registry.js';
 import { resolveStopMessageScope } from './engine/routing-state/store.js';
@@ -349,38 +346,3 @@ function cleanRoutingInstructionMarkersInPlace(request) {
         }
     }
 }
-function collectClientScopedInstructions(request) {
-    const messages = Array.isArray(request.messages)
-        ? request.messages
-        : [];
-    const responsesContext = request.semantics && typeof request.semantics === 'object'
-        ? request.semantics.responses?.context
-        : undefined;
-    const responsesHasMarker = hasRoutingInstructionMarkerInResponsesContext(responsesContext);
-    const latestUserHasMarker = hasLatestUserRoutingInstructionMarker(messages) || responsesHasMarker;
-    if (!latestUserHasMarker && !messages.some((message) => {
-        if (!message || typeof message !== 'object') {
-            return false;
-        }
-        const record = message;
-        return record.role === 'user' && typeof record.content === 'string' && ROUTING_INSTRUCTION_MARKER_PATTERN.test(record.content);
-    })) {
-        return { instructions: [], latestUserHasMarker };
-    }
-    let instructions = parseRoutingInstructions(messages);
-    if (instructions.length === 0 && responsesHasMarker) {
-        const responsesLatestUserText = getLatestUserTextFromResponsesContext(responsesContext);
-        if (responsesLatestUserText) {
-            instructions = parseRoutingInstructions([{ role: 'user', content: responsesLatestUserText }]);
-        }
-    }
-    return { instructions, latestUserHasMarker };
-}
-function isClientScopedInstruction(instruction) {
-    return (instruction.type === 'stopMessageSet' ||
-        instruction.type === 'stopMessageMode' ||
-        instruction.type === 'stopMessageClear' ||
-        instruction.type === 'preCommandSet' ||
-        instruction.type === 'preCommandClear' ||
-        instruction.type === 'clear');
-}

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

@@ -3,6 +3,46 @@ import { extractAntigravityGeminiSessionIdWithNative } from './engine-selection/
 import { detectCodingTool, detectLastAssistantToolCategory, detectVisionTool, detectWebSearchToolDeclared, detectWebTool, extractMeaningfulDeclaredToolNames } from './tool-signals.js';
 import { computeRequestTokens } from './token-estimator.js';
 const THINKING_KEYWORDS = ['let me think', 'chain of thought', 'cot', 'reason step', 'deliberate'];
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+}
+function getLatestResponsesContextMessage(request) {
+    const contextInput = asRecord(request.semantics)?.responses;
+    const context = asRecord(contextInput)?.context;
+    const input = Array.isArray(asRecord(context)?.input) ? asRecord(context)?.input : [];
+    for (let idx = input.length - 1; idx >= 0; idx -= 1) {
+        const entry = asRecord(input[idx]);
+        if (!entry) {
+            continue;
+        }
+        const entryType = typeof entry.type === 'string' && entry.type.trim()
+            ? entry.type.trim().toLowerCase()
+            : 'message';
+        if (entryType !== 'message') {
+            continue;
+        }
+        const role = typeof entry.role === 'string' && entry.role.trim()
+            ? entry.role.trim().toLowerCase()
+            : 'user';
+        if (role !== 'user' && role !== 'assistant' && role !== 'tool') {
+            continue;
+        }
+        const content = entry.content;
+        if (typeof content !== 'string' && !Array.isArray(content)) {
+            continue;
+        }
+        return {
+            role,
+            message: {
+                role: role,
+                content: content
+            }
+        };
+    }
+    return null;
+}
 export function buildRoutingFeatures(request, metadata) {
     const antigravitySessionId = (() => {
         try {
@@ -18,10 +58,11 @@ export function buildRoutingFeatures(request, metadata) {
             return undefined;
         }
     })();
-    const latestMessageRole = getLatestMessageRole(request.messages);
-    const latestMessage = Array.isArray(request.messages) && request.messages.length
+    const responsesLatestMessage = getLatestResponsesContextMessage(request);
+    const latestMessageRole = responsesLatestMessage?.role || getLatestMessageRole(request.messages);
+    const latestMessage = responsesLatestMessage?.message || (Array.isArray(request.messages) && request.messages.length
         ? request.messages[request.messages.length - 1]
-        : undefined;
+        : undefined);
     const assistantMessages = request.messages.filter((msg) => msg.role === 'assistant');
     const latestUserText = latestMessageRole === 'user' && latestMessage
         ? extractMessageText(latestMessage)

package/dist/router/virtual-router/routing-instructions/parse.d.ts

@@ -1,18 +1,6 @@
 import type { StandardizedMessage } from '../../../conversion/hub/types/standardized.js';
 import type { RoutingInstruction } from './types.js';
 export declare function parseRoutingInstructions(messages: StandardizedMessage[]): RoutingInstruction[];
-/**
- * 解析并预处理路由指令，优先处理 clear 指令，确保新指令能够覆盖旧状态。
- * 返回清理后的指令列表，移除冗余的 stopMessageSet 指令。
- */
 export declare function parseAndPreprocessRoutingInstructions(messages: StandardizedMessage[]): RoutingInstruction[];
-/**
- * 提取 clear 指令（如果存在）。用于在路由选择前优先执行清理操作。
- * @returns 是否存在 clear 指令
- */
 export declare function extractClearInstruction(messages: StandardizedMessage[]): boolean;
-/**
- * 提取 stopMessageClear 指令（如果存在）。
- * @returns 是否存在 stopMessageClear 指令
- */
 export declare function extractStopMessageClearInstruction(messages: StandardizedMessage[]): boolean;