@jsonstudio/llms 0.6.1643 → 0.6.1739

package/dist/router/virtual-router/engine-selection/route-utils.js

@@ -61,10 +61,27 @@ export function buildRouteCandidates(requestedRoute, classificationCandidates, f
             }
         }
     }
+    if (features.hasImageAttachment) {
+        const allRouteNames = Object.keys(routing);
+        for (const routeName of allRouteNames) {
+            if (!routeHasTargets(routing[routeName])) {
+                continue;
+            }
+            if (!routeSupportsModel(routeName, 'kimi-k2.5', routing, providerRegistry)) {
+                continue;
+            }
+            if (!baseList.includes(routeName)) {
+                baseList.push(routeName);
+            }
+        }
+    }
     let ordered = sortByPriority(baseList);
     if (features.hasImageAttachment && !forceVision) {
         ordered = reorderForInlineVision(ordered, routing, providerRegistry);
     }
+    if (features.hasImageAttachment) {
+        ordered = reorderForPreferredModel(ordered, 'kimi-k2.5', routing, providerRegistry);
+    }
     const deduped = [];
     for (const routeName of ordered) {
         if (routeName && !deduped.includes(routeName)) {
@@ -142,3 +159,43 @@ function routeSupportsInlineVision(routeName, routing, providerRegistry) {
     }
     return false;
 }
+function reorderForPreferredModel(routeNames, modelId, routing, providerRegistry) {
+    const unique = Array.from(new Set(routeNames.filter(Boolean)));
+    if (!unique.length) {
+        return unique;
+    }
+    const preferred = unique.filter((routeName) => routeSupportsModel(routeName, modelId, routing, providerRegistry));
+    if (!preferred.length) {
+        return unique;
+    }
+    const remaining = unique.filter((routeName) => !preferred.includes(routeName));
+    return [...preferred, ...remaining];
+}
+function routeSupportsModel(routeName, modelId, routing, providerRegistry) {
+    const normalizedModel = modelId.trim().toLowerCase();
+    if (!normalizedModel) {
+        return false;
+    }
+    const pools = routing[routeName];
+    if (!Array.isArray(pools)) {
+        return false;
+    }
+    for (const pool of pools) {
+        if (!Array.isArray(pool.targets)) {
+            continue;
+        }
+        for (const providerKey of pool.targets) {
+            try {
+                const profile = providerRegistry.get(providerKey);
+                const candidate = typeof profile.modelId === 'string' ? profile.modelId.trim().toLowerCase() : '';
+                if (candidate === normalizedModel) {
+                    return true;
+                }
+            }
+            catch {
+                // ignore unknown providers when probing capabilities
+            }
+        }
+    }
+    return false;
+}

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

@@ -282,7 +282,8 @@ export function selectProviderKeyFromCandidatePool(opts) {
         if (!bucket.length) {
             continue;
         }
-        bucket.sort((a, b) => (a.penalty - b.penalty) || (a.order - b.order));
+        // Keep candidate ordering stable (config order). Availability/blacklist/cooldown still apply.
+        bucket.sort((a, b) => a.order - b.order);
         let bucketCandidates = bucket.map((item) => item.key);
         // Single-provider pool should never be "emptied" by health/cooldown.
         if (bucketCandidates.length === 1) {
@@ -299,10 +300,6 @@ export function selectProviderKeyFromCandidatePool(opts) {
             deps,
             excludedKeys
         });
-        const bucketPenaltyMap = {};
-        for (const item of bucket) {
-            bucketPenaltyMap[item.key] = item.penalty;
-        }
         const bucketWeights = {};
         const bucketMultipliers = {};
         for (const item of bucket) {
@@ -337,8 +334,7 @@ export function selectProviderKeyFromCandidatePool(opts) {
                     candidates: bucketCandidates,
                     orderedTargets: tier.targets,
                     providerRegistry: deps.providerRegistry,
-                    availabilityCheck: isAvailable,
-                    penalties: bucketPenaltyMap
+                    availabilityCheck: isAvailable
                 });
                 if (!group) {
                     continue;
@@ -359,50 +355,14 @@ export function selectProviderKeyFromCandidatePool(opts) {
                 }
                 continue;
             }
-            if (isRecoveryAttempt && healthWeightedCfg.enabled && healthWeightedCfg.recoverToBestOnRetry) {
-                let best = null;
-                let bestM = Number.NEGATIVE_INFINITY;
-                for (const key of bucketCandidates) {
-                    if (!isAvailable(key))
-                        continue;
-                    const m = bucketMultipliers[key] ?? 1;
-                    if (m > bestM) {
-                        bestM = m;
-                        best = key;
-                    }
-                }
-                if (best) {
-                    return best;
-                }
-                continue;
-            }
-            else if (isRecoveryAttempt) {
-                const recovered = selectFirstAvailable(bucketCandidates);
-                if (recovered)
-                    return recovered;
-                continue;
-            }
+            const recovered = selectFirstAvailable(bucketCandidates);
+            if (recovered)
+                return recovered;
+            continue;
             // (unreachable) recovery handled above
         }
         else {
-            if (isRecoveryAttempt && healthWeightedCfg.enabled && healthWeightedCfg.recoverToBestOnRetry) {
-                let best = null;
-                let bestM = Number.NEGATIVE_INFINITY;
-                for (const key of bucketCandidates) {
-                    if (!isAvailable(key))
-                        continue;
-                    const m = bucketMultipliers[key] ?? 1;
-                    if (m > bestM) {
-                        bestM = m;
-                        best = key;
-                    }
-                }
-                if (best) {
-                    return best;
-                }
-                continue;
-            }
-            else if (isRecoveryAttempt) {
+            if (isRecoveryAttempt) {
                 const recovered = selectFirstAvailable(bucketCandidates);
                 if (recovered)
                     return recovered;

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

@@ -108,6 +108,14 @@ function resolveSessionScopeKey(metadata) {
     if (conversationId) {
         return `conversation:${conversationId}`;
     }
+    // Antigravity-Manager alignment: when the client does not provide session_id/conversation_id,
+    // fall back to the derived antigravitySessionId so alias/session binding still works.
+    const antigravitySessionId = typeof record.antigravitySessionId === 'string'
+        ? String(record.antigravitySessionId).trim()
+        : '';
+    if (antigravitySessionId) {
+        return `session:${antigravitySessionId}`;
+    }
     return null;
 }
 function buildScopedSessionKey(sessionKey) {
@@ -376,29 +384,38 @@ export function trySelectFromTier(routeName, tier, stickyKey, estimatedTokens, f
         }
         targets = filtered;
     }
-    if (features.hasImageAttachment && (routeName === DEFAULT_ROUTE || routeName === 'thinking')) {
-        const prioritized = [];
-        const fallthrough = [];
-        for (const key of targets) {
-            try {
-                const profile = deps.providerRegistry.get(key);
-                if (profile.providerType === 'responses') {
-                    prioritized.push(key);
-                }
-                else if (profile.providerType === 'gemini') {
-                    prioritized.push(key);
+    if (features.hasImageAttachment) {
+        const kimiTargets = targets.filter((key) => {
+            const modelId = getProviderModelId(key, deps.providerRegistry) ?? '';
+            return modelId.trim().toLowerCase() === 'kimi-k2.5';
+        });
+        if (kimiTargets.length) {
+            targets = kimiTargets;
+        }
+        else if (routeName === DEFAULT_ROUTE || routeName === 'thinking') {
+            const prioritized = [];
+            const fallthrough = [];
+            for (const key of targets) {
+                try {
+                    const profile = deps.providerRegistry.get(key);
+                    if (profile.providerType === 'responses') {
+                        prioritized.push(key);
+                    }
+                    else if (profile.providerType === 'gemini') {
+                        prioritized.push(key);
+                    }
+                    else {
+                        fallthrough.push(key);
+                    }
                 }
-                else {
+                catch {
                     fallthrough.push(key);
                 }
             }
-            catch {
-                fallthrough.push(key);
+            if (prioritized.length) {
+                targets = prioritized;
             }
         }
-        if (prioritized.length) {
-            targets = prioritized;
-        }
     }
     if (!targets.length) {
         const leaseHint = leaseResult.blocked > 0

package/dist/router/virtual-router/engine-selection.d.ts

@@ -1,13 +1 @@
-import type { ClassificationResult, RouterMetadataInput, RoutingFeatures } from './types.js';
-import type { RoutingInstructionState } from './routing-instructions.js';
-import type { SelectionDeps } from './engine-selection/selection-deps.js';
-export { selectDirectProviderModel } from './engine-selection/direct-provider-model.js';
-export { selectFromStickyPool } from './engine-selection/sticky-pool.js';
-export declare function selectProviderImpl(requestedRoute: string, metadata: RouterMetadataInput, classification: ClassificationResult, features: RoutingFeatures, activeState: RoutingInstructionState, deps: SelectionDeps, options?: {
-    routingState?: RoutingInstructionState;
-}): {
-    providerKey: string;
-    routeUsed: string;
-    pool: string[];
-    poolId?: string;
-};
+export { selectProviderImpl, selectDirectProviderModel, selectFromStickyPool } from './engine/routing-pools/index.js';

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

@@ -1,225 +1 @@
-import { DEFAULT_ROUTE, VirtualRouterError, VirtualRouterErrorCode } from './types.js';
-import { extractExcludedProviderKeySet, extractProviderId } from './engine-selection/key-parsing.js';
-import { trySelectFromTier } from './engine-selection/tier-selection.js';
-import { resolveInstructionTarget } from './engine-selection/instruction-target.js';
-import { filterCandidatesByRoutingState } from './engine-selection/routing-state-filter.js';
-import { selectFromStickyPool as selectFromStickyPoolImpl } from './engine-selection/sticky-pool.js';
-export { selectDirectProviderModel } from './engine-selection/direct-provider-model.js';
-export { selectFromStickyPool } from './engine-selection/sticky-pool.js';
-import { buildRouteCandidates, extendRouteCandidatesForState, initializeRouteQueue, normalizeRouteAlias, routeHasTargets, sortRoutePools } from './engine-selection/route-utils.js';
-export function selectProviderImpl(requestedRoute, metadata, classification, features, activeState, deps, options = {}) {
-    const state = options.routingState ?? activeState;
-    const quotaView = deps.quotaView;
-    const quotaNow = quotaView ? Date.now() : 0;
-    const isAllowedByQuota = (key) => {
-        if (!quotaView) {
-            return true;
-        }
-        const entry = quotaView(key);
-        if (!entry) {
-            return true;
-        }
-        if (!entry.inPool) {
-            return false;
-        }
-        if (entry.cooldownUntil && entry.cooldownUntil > quotaNow) {
-            return false;
-        }
-        if (entry.blacklistUntil && entry.blacklistUntil > quotaNow) {
-            return false;
-        }
-        return true;
-    };
-    const excludedProviderKeys = extractExcludedProviderKeySet(features.metadata);
-    const forcedResolution = state.forcedTarget ? resolveInstructionTarget(state.forcedTarget, deps.providerRegistry) : null;
-    if (forcedResolution && forcedResolution.mode === 'exact') {
-        const forcedKey = forcedResolution.keys[0];
-        if (!excludedProviderKeys.has(forcedKey) && !deps.isProviderCoolingDown(forcedKey) && isAllowedByQuota(forcedKey)) {
-            return {
-                providerKey: forcedKey,
-                routeUsed: requestedRoute,
-                pool: [forcedKey],
-                poolId: 'forced'
-            };
-        }
-    }
-    let stickyResolution = null;
-    let stickyKeySet;
-    if (!forcedResolution && state.stickyTarget) {
-        stickyResolution = resolveInstructionTarget(state.stickyTarget, deps.providerRegistry);
-        if (stickyResolution && stickyResolution.mode === 'exact') {
-            const stickyKey = stickyResolution.keys[0];
-            if ((deps.quotaView ? true : deps.healthManager.isAvailable(stickyKey)) &&
-                !excludedProviderKeys.has(stickyKey) &&
-                !deps.isProviderCoolingDown(stickyKey) &&
-                isAllowedByQuota(stickyKey)) {
-                return {
-                    providerKey: stickyKey,
-                    routeUsed: requestedRoute,
-                    pool: [stickyKey],
-                    poolId: 'sticky'
-                };
-            }
-        }
-        if (stickyResolution && stickyResolution.mode === 'filter' && stickyResolution.keys.length > 0) {
-            const liveKeys = stickyResolution.keys.filter((key) => (deps.quotaView ? true : deps.healthManager.isAvailable(key)) &&
-                !excludedProviderKeys.has(key) &&
-                !deps.isProviderCoolingDown(key) &&
-                isAllowedByQuota(key));
-            if (liveKeys.length > 0) {
-                stickyKeySet = new Set(liveKeys);
-            }
-        }
-    }
-    const allowAliasRotation = Boolean(state.stickyTarget) &&
-        !state.stickyTarget?.keyAlias &&
-        state.stickyTarget?.keyIndex === undefined;
-    if (forcedResolution && forcedResolution.mode === 'filter') {
-        const forcedKeySet = new Set(forcedResolution.keys);
-        if (forcedKeySet.size > 0) {
-            for (const key of Array.from(forcedKeySet)) {
-                if (excludedProviderKeys.has(key) || deps.isProviderCoolingDown(key)) {
-                    forcedKeySet.delete(key);
-                }
-            }
-        }
-        if (forcedKeySet.size > 0) {
-            const candidates = extendRouteCandidatesForState(buildRouteCandidates(requestedRoute, classification.candidates, features, deps.routing, deps.providerRegistry), state, deps.routing);
-            const filteredCandidates = filterCandidatesByRoutingState(candidates, state, deps.routing, deps.providerRegistry);
-            if (filteredCandidates.length === 0) {
-                const allowedProviders = Array.from(state.allowedProviders);
-                const disabledProviders = Array.from(state.disabledProviders);
-                const providersInRouting = new Set();
-                for (const pools of Object.values(deps.routing)) {
-                    if (!Array.isArray(pools))
-                        continue;
-                    for (const pool of pools) {
-                        if (!pool || !Array.isArray(pool.targets))
-                            continue;
-                        for (const key of pool.targets) {
-                            if (typeof key !== 'string' || !key)
-                                continue;
-                            const providerId = extractProviderId(key);
-                            if (providerId) {
-                                providersInRouting.add(providerId);
-                            }
-                        }
-                    }
-                }
-                const missingAllowedProviders = allowedProviders.length > 0 ? allowedProviders.filter((provider) => !providersInRouting.has(provider)) : [];
-                const hint = (() => {
-                    if (missingAllowedProviders.length > 0) {
-                        return `Allowed providers not present in routing pools: ${missingAllowedProviders.join(', ')}`;
-                    }
-                    return 'Routing instructions excluded all route candidates';
-                })();
-                throw new VirtualRouterError(`No available providers after applying routing instructions (${hint}). ` +
-                    `Tip: remove/adjust <**...**> routing instructions (or use <**clear**>), or add providers/models to routing.`, VirtualRouterErrorCode.PROVIDER_NOT_AVAILABLE, {
-                    requestedRoute,
-                    allowedProviders,
-                    disabledProviders,
-                    missingAllowedProviders
-                });
-            }
-            return selectFromCandidates(filteredCandidates, metadata, classification, features, state, deps, {
-                requiredProviderKeys: forcedKeySet,
-                allowAliasRotation
-            });
-        }
-    }
-    if (stickyKeySet && stickyKeySet.size > 0) {
-        const stickySelection = selectFromStickyPoolImpl(stickyKeySet, metadata, features, state, deps, { allowAliasRotation });
-        if (stickySelection) {
-            return stickySelection;
-        }
-    }
-    const candidates = buildRouteCandidates(requestedRoute, classification.candidates, features, deps.routing, deps.providerRegistry);
-    const expandedCandidates = extendRouteCandidatesForState(candidates, state, deps.routing);
-    const filteredCandidates = filterCandidatesByRoutingState(expandedCandidates, state, deps.routing, deps.providerRegistry);
-    if (filteredCandidates.length === 0) {
-        const allowedProviders = Array.from(state.allowedProviders);
-        const disabledProviders = Array.from(state.disabledProviders);
-        const providersInRouting = new Set();
-        for (const pools of Object.values(deps.routing)) {
-            if (!Array.isArray(pools))
-                continue;
-            for (const pool of pools) {
-                if (!pool || !Array.isArray(pool.targets))
-                    continue;
-                for (const key of pool.targets) {
-                    if (typeof key !== 'string' || !key)
-                        continue;
-                    const providerId = extractProviderId(key);
-                    if (providerId) {
-                        providersInRouting.add(providerId);
-                    }
-                }
-            }
-        }
-        const missingAllowedProviders = allowedProviders.length > 0 ? allowedProviders.filter((provider) => !providersInRouting.has(provider)) : [];
-        const hint = (() => {
-            if (missingAllowedProviders.length > 0) {
-                return `Allowed providers not present in routing pools: ${missingAllowedProviders.join(', ')}`;
-            }
-            return 'Routing instructions excluded all route candidates';
-        })();
-        throw new VirtualRouterError(`No available providers after applying routing instructions (${hint}). ` +
-            `Tip: remove/adjust <**...**> routing instructions (or use <**clear**>), or add providers/models to routing.`, VirtualRouterErrorCode.PROVIDER_NOT_AVAILABLE, {
-            requestedRoute,
-            allowedProviders,
-            disabledProviders,
-            missingAllowedProviders
-        });
-    }
-    return selectFromCandidates(filteredCandidates, metadata, classification, features, state, deps, {
-        allowAliasRotation
-    });
-}
-function selectFromCandidates(routes, metadata, classification, features, state, deps, options) {
-    const allowedProviders = new Set(state.allowedProviders);
-    const disabledProviders = new Set(state.disabledProviders);
-    const disabledKeysMap = new Map(Array.from(state.disabledKeys.entries()).map(([provider, keys]) => [
-        provider,
-        new Set(Array.from(keys).map((k) => (typeof k === 'string' ? k : k + 1)))
-    ]));
-    const disabledModels = new Map(Array.from(state.disabledModels.entries()).map(([provider, models]) => [provider, new Set(models)]));
-    const stickyKey = options.allowAliasRotation ? undefined : deps.resolveStickyKey(metadata);
-    const attempted = [];
-    const visitedRoutes = new Set();
-    const routeQueue = initializeRouteQueue(routes);
-    const estimatedTokens = typeof features.estimatedTokens === 'number' && Number.isFinite(features.estimatedTokens)
-        ? Math.max(0, features.estimatedTokens)
-        : 0;
-    while (routeQueue.length) {
-        const routeName = routeQueue.shift();
-        if (visitedRoutes.has(routeName)) {
-            continue;
-        }
-        const routePools = deps.routing[routeName];
-        if (!routeHasTargets(routePools)) {
-            visitedRoutes.add(routeName);
-            attempted.push(`${routeName}:empty`);
-            continue;
-        }
-        visitedRoutes.add(routeName);
-        const orderedPools = sortRoutePools(routePools);
-        for (const poolTier of orderedPools) {
-            const { providerKey, poolTargets, tierId, failureHint } = trySelectFromTier(routeName, poolTier, stickyKey, estimatedTokens, features, deps, {
-                disabledProviders,
-                disabledKeysMap,
-                allowedProviders,
-                disabledModels,
-                requiredProviderKeys: options.requiredProviderKeys,
-                allowAliasRotation: options.allowAliasRotation
-            });
-            if (providerKey) {
-                return { providerKey, routeUsed: routeName, pool: poolTargets, poolId: tierId };
-            }
-            if (failureHint) {
-                attempted.push(failureHint);
-            }
-        }
-    }
-    const requestedRoute = normalizeRouteAlias(classification.routeName || DEFAULT_ROUTE);
-    throw new VirtualRouterError(`All providers unavailable for route ${requestedRoute}`, VirtualRouterErrorCode.PROVIDER_NOT_AVAILABLE, { routeName: requestedRoute, attempted });
-}
+export { selectProviderImpl, selectDirectProviderModel, selectFromStickyPool } from './engine/routing-pools/index.js';

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

@@ -70,26 +70,9 @@ export declare class VirtualRouterEngine {
     private providerHealthConfig;
     private resolveStickyKey;
     private resolveSessionScope;
-    private resolveAntigravityAliasReuseCooldownMs;
-    private resolveAntigravityLeaseScope;
-    private buildScopedSessionKey;
-    private buildAntigravityLeaseRuntimeKey;
-    private extractRuntimeKey;
-    private recordAntigravitySessionLease;
-    private resolveAntigravityAliasLeasePersistPath;
-    private hydrateAntigravityAliasLeaseStoreIfNeeded;
-    private scheduleAntigravityAliasLeaseStoreFlush;
-    private flushAntigravityAliasLeaseStoreSync;
-    private resolveStopMessageScope;
-    private getRoutingInstructionState;
-    private buildMetadataInstructions;
-    private parseMetadataDisableDescriptor;
-    private parseMetadataForceProviderKey;
-    private resolveRoutingMode;
     private resolveInstructionTarget;
     private filterCandidatesByRoutingState;
     private selectFromCandidates;
-    private extractProviderId;
     /**
      * 在已有候选路由集合上，筛选出真正挂载了 sticky 池内 providerKey 的路由，
      * 并按 ROUTE_PRIORITY 进行排序；同时显式排除 tools 路由，保证一旦进入
@@ -104,13 +87,11 @@ export declare class VirtualRouterEngine {
      * - 仍然尊重 allowed/disabledProviders、disabledKeys、disabledModels 以及上下文长度。
      */
     private selectFromStickyPool;
-    private extractKeyAlias;
-    private normalizeAliasDescriptor;
-    private extractKeyIndex;
-    private getProviderModelId;
     private extractExcludedProviderKeySet;
     private buildRouteCandidates;
     private reorderForInlineVision;
+    private reorderForPreferredModel;
+    private routeSupportsModel;
     private routeSupportsInlineVision;
     private sortByPriority;
     private routeWeight;
@@ -119,8 +100,6 @@ export declare class VirtualRouterEngine {
     private hasPrimaryPool;
     private sortRoutePools;
     private flattenPoolTargets;
-    private isRoutingStateEmpty;
-    private persistRoutingInstructionState;
     private markProviderCooldown;
     private clearProviderCooldown;
     private isProviderCoolingDown;