@jsonstudio/llms 0.6.1399 → 0.6.1402

package/dist/conversion/shared/mcp-injection.js

@@ -98,6 +98,21 @@ export function injectMcpToolsForChat(tools, discoveredServers) {
         out.push(t);
         keep.add(lower);
     }
+    // Ensure list exists when user did not provide it
+    if (!keep.has('list_mcp_resources')) {
+        out.push({ type: 'function', function: { name: 'list_mcp_resources', description: buildListResourcesDescription(discoveredServers), parameters: obj({ server: listServers, filter: { type: 'string' }, root: { type: 'string' } }) } });
+    }
+    // Ensure templates exists (safe to call after list_mcp_resources)
+    if (!keep.has('list_mcp_resource_templates')) {
+        out.push({
+            type: 'function',
+            function: {
+                name: 'list_mcp_resource_templates',
+                description: buildListTemplatesDescription(discoveredServers),
+                parameters: obj({ server: templateServer, cursor: { type: 'string' } })
+            }
+        });
+    }
     return out;
 }
 export function injectMcpToolsForResponses(tools, discoveredServers) {
@@ -140,5 +155,19 @@ export function injectMcpToolsForResponses(tools, discoveredServers) {
         out.push(t);
         keep.add(lower);
     }
+    if (!keep.has('list_mcp_resources')) {
+        out.push({ type: 'function', function: { name: 'list_mcp_resources', description: buildListResourcesDescription(discoveredServers), parameters: obj({ server: listServers, filter: { type: 'string' }, root: { type: 'string' } }) } });
+        keep.add('list_mcp_resources');
+    }
+    if (!keep.has('list_mcp_resource_templates')) {
+        out.push({
+            type: 'function',
+            function: {
+                name: 'list_mcp_resource_templates',
+                description: buildListTemplatesDescription(discoveredServers),
+                parameters: obj({ server: templateServer, cursor: { type: 'string' } })
+            }
+        });
+    }
     return out;
 }

package/dist/conversion/shared/openai-message-normalize.js

@@ -3,14 +3,6 @@ import { injectMcpToolsForChat } from './mcp-injection.js';
 // with the deprecated "openai-normalizer" module entry). This file contains the
 // previously-implemented logic from openai-normalize.ts.
 // Legacy tooling stage removed for Chat; tool canonicalization lives in codecs
-function isMcpToolName(name) {
-    if (typeof name !== 'string')
-        return false;
-    const lowered = name.trim().toLowerCase();
-    return (lowered === 'list_mcp_resources' ||
-        lowered === 'list_mcp_resource_templates' ||
-        lowered === 'read_mcp_resource');
-}
 export function normalizeChatRequest(request) {
     if (!request || typeof request !== 'object')
         return request;
@@ -132,15 +124,9 @@ export function normalizeChatRequest(request) {
                     }
                 }
                 catch { /* ignore */ }
-                const currentTools = Array.isArray(normalized.tools)
-                    ? normalized.tools
-                    : undefined;
-                // IMPORTANT: Do not force-inject MCP tools. If the inbound request doesn't include MCP tools,
-                // keep tools untouched (and do not create a tools=[] placeholder).
-                if (currentTools && currentTools.some((t) => isMcpToolName(t?.function?.name))) {
-                    const discovered = Array.from(known);
-                    normalized.tools = injectMcpToolsForChat(currentTools, discovered);
-                }
+                const discovered = Array.from(known);
+                const currentTools = Array.isArray(normalized.tools) ? normalized.tools : [];
+                normalized.tools = injectMcpToolsForChat(currentTools, discovered);
             }
         }
         catch { /* ignore MCP injection */ }

package/dist/filters/special/request-tool-list-filter.js

@@ -184,6 +184,9 @@ function ensureFunctionTool(tools, name, description, parameters) {
             fn.description = description;
         fn.parameters = parameters;
     }
+    else {
+        tools.push({ type: 'function', function: { name, description, parameters } });
+    }
 }
 function removeToolByName(tools, name) {
     for (let i = tools.length - 1; i >= 0; i--) {
@@ -205,22 +208,15 @@ export class RequestToolListFilter {
         try {
             const out = JSON.parse(JSON.stringify(input || {}));
             const hadIncomingTools = Array.isArray(out.tools);
-            // IMPORTANT: do not force-inject any tools. If the inbound request didn't include `tools`,
-            // keep it absent.
+            const tools = hadIncomingTools ? out.tools : [];
             if (!hadIncomingTools) {
-                return { ok: true, data: out };
-            }
-            const tools = out.tools;
-            const hasMcpTool = Array.isArray(tools) &&
-                tools.some((t) => t && typeof t === 'object' && t.type === 'function' && t.function && typeof t.function.name === 'string' && (t.function.name === 'list_mcp_resources' ||
-                    t.function.name === 'list_mcp_resource_templates' ||
-                    t.function.name === 'read_mcp_resource'));
-            if (!hasMcpTool) {
-                return { ok: true, data: out };
+                out.tools = tools;
             }
             const mode = envMode();
             if (mode === 'off') {
-                // Explicitly do not mutate tools when disabled.
+                if (!hadIncomingTools && tools.length === 0) {
+                    delete out.tools;
+                }
                 return { ok: true, data: out };
             }
             const messages = Array.isArray(out.messages) ? out.messages : [];
@@ -239,7 +235,15 @@ export class RequestToolListFilter {
                 return `Known MCP servers: ${shown.join(', ')}${suffix}.`;
             };
             const mcpServerReminder = 'Note: arguments.server is an MCP server label (NOT a tool name like shell/exec_command/apply_patch).';
-            // IMPORTANT: do not remove tools based on session history. Tool list must remain stable for Gemini/Antigravity.
+            // If the session already attempted list_mcp_resources and got an empty/unsupported response,
+            // stop exposing MCP *resource* tools to avoid repeated "server" probing loops.
+            if (mcpListEmpty) {
+                removeToolByName(tools, 'list_mcp_resources');
+                removeToolByName(tools, 'list_mcp_resource_templates');
+                removeToolByName(tools, 'read_mcp_resource');
+                out.tools = tools;
+                return { ok: true, data: out };
+            }
             // MCP tool schemas
             const listResParams = {
                 type: 'object',
@@ -303,6 +307,10 @@ export class RequestToolListFilter {
                     withEnum.properties.server = { type: 'string', enum: knownServers };
                     ensureFunctionTool(tools, 'read_mcp_resource', readDescription, withEnum);
                 }
+                else {
+                    // remove any existing read tool to prevent premature exposure
+                    removeToolByName(tools, 'read_mcp_resource');
+                }
             }
             out.tools = tools;
             return { ok: true, data: out };

package/dist/filters/special/tool-filter-hooks.js

@@ -261,9 +261,66 @@ const mcpToolHook = ctx => {
         }
         return;
     }
-    // IMPORTANT: Do not mutate MCP tool lists based on session history.
-    // Gemini/Antigravity are sensitive to tool-list drift (history vs current declarations).
-    // We keep the inbound tool list stable and rely on schema/description hints instead.
+    // 会话内阶段性策略：
+    // 1) 如果 list_mcp_resources 从未在本会话中被请求过 → 仅暴露 list_mcp_resources，过滤 read/templates。
+    // 2) 如果 list_mcp_resources 已请求且结果为空 → 完全过滤所有 MCP 工具。
+    const { listRequested, listEmpty } = deriveMcpSessionState(messages);
+    const next = [];
+    for (const t of tools) {
+        let name = '';
+        try {
+            name =
+                t &&
+                    typeof t === 'object' &&
+                    t.function &&
+                    typeof t.function.name === 'string'
+                    ? String(t.function.name)
+                    : '';
+        }
+        catch {
+            name = '';
+        }
+        const lower = name.toLowerCase();
+        const isMcp = isMcpToolName(name);
+        if (!isMcp) {
+            next.push(t);
+            continue;
+        }
+        if (!listRequested) {
+            // list 未被请求过：保留 list_mcp_resources，其它 MCP 工具全部过滤
+            if (lower === 'list_mcp_resources') {
+                next.push(t);
+                recordDecision({
+                    name,
+                    action: 'allow',
+                    category: 'mcp',
+                    reason: 'mcp_list_exposed_before_first_use',
+                });
+            }
+            else {
+                recordDecision({
+                    name,
+                    action: 'block',
+                    category: 'mcp',
+                    reason: 'mcp_non_list_blocked_until_list_called',
+                });
+            }
+            continue;
+        }
+        if (listEmpty) {
+            // list 已请求且结果为空：完全屏蔽所有 MCP 工具
+            recordDecision({
+                name,
+                action: 'block',
+                category: 'mcp',
+                reason: 'mcp_disabled_for_session_after_empty_list',
+            });
+            continue;
+        }
+        // list 已请求且非空：保留现有行为（交由其它层/配置控制）
+        next.push(t);
+    }
+    ctx.tools = next;
 };
 const requestHooks = [visionToolHook, mcpToolHook];
 export class ToolFilterHookFilter {

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

@@ -612,6 +612,14 @@ function resolveCompatibilityProfile(providerId, provider) {
     if (legacyFields.length > 0) {
         throw new VirtualRouterError(`Provider "${providerId}" uses legacy compatibility field(s): ${legacyFields.join(', ')}. Rename to "compatibilityProfile".`, VirtualRouterErrorCode.CONFIG_ERROR);
     }
+    const normalizedId = providerId.trim().toLowerCase();
+    const providerType = String(provider.providerType ?? provider.type ?? provider.protocol ?? '').toLowerCase();
+    if (normalizedId === 'antigravity' ||
+        normalizedId === 'gemini-cli' ||
+        providerType.includes('antigravity') ||
+        providerType.includes('gemini-cli')) {
+        return 'chat:gemini-cli';
+    }
     return 'compat:passthrough';
 }
 function normalizeProcessMode(value) {
@@ -1241,12 +1249,6 @@ function coerceAliasSelectionStrategy(value) {
     if (normalized === 'sticky-queue' || normalized === 'sticky_queue' || normalized === 'stickyqueue') {
         return 'sticky-queue';
     }
-    if (normalized === 'best-quota' ||
-        normalized === 'best_quota' ||
-        normalized === 'quota-best' ||
-        normalized === 'quota_best') {
-        return 'best-quota';
-    }
     return undefined;
 }
 function coerceRatio(value) {

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

@@ -7,6 +7,7 @@ type DebugLike = {
 export declare function resetRateLimitBackoffForProvider(providerKey: string): void;
 export declare function handleProviderFailureImpl(event: ProviderFailureEvent, healthManager: ProviderHealthManager, healthConfig: Required<ProviderHealthConfig>, markProviderCooldown: (providerKey: string, cooldownMs: number | undefined) => void): void;
 export declare function mapProviderErrorImpl(event: ProviderErrorEvent, healthConfig: Required<ProviderHealthConfig>): ProviderFailureEvent | null;
+export declare function applySeriesCooldownImpl(event: ProviderErrorEvent, providerRegistry: ProviderRegistry, healthManager: ProviderHealthManager, markProviderCooldown: (providerKey: string, cooldownMs: number | undefined) => void, debug?: DebugLike): void;
 /**
  * 处理来自 Host 侧的配额恢复事件：
  * - 清除指定 providerKey 在健康管理器中的熔断/冷却状态；
@@ -17,6 +18,5 @@ export declare function mapProviderErrorImpl(event: ProviderErrorEvent, healthCo
  */
 export declare function applyQuotaRecoveryImpl(event: ProviderErrorEvent, healthManager: ProviderHealthManager, clearProviderCooldown: (providerKey: string) => void, debug?: DebugLike): boolean;
 export declare function applyQuotaDepletedImpl(event: ProviderErrorEvent, healthManager: ProviderHealthManager, markProviderCooldown: (providerKey: string, cooldownMs: number | undefined) => void, debug?: DebugLike): boolean;
-export declare function applySeriesCooldownImpl(event: ProviderErrorEvent, _providerRegistry: ProviderRegistry, _healthManager: ProviderHealthManager, _markProviderCooldown: (providerKey: string, cooldownMs: number | undefined) => void, debug?: DebugLike): boolean;
 export declare function deriveReason(code: string, stage: string, statusCode?: number): string;
 export {};

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

@@ -1,3 +1,4 @@
+const SERIES_COOLDOWN_DETAIL_KEY = 'virtualRouterSeriesCooldown';
 const QUOTA_RECOVERY_DETAIL_KEY = 'virtualRouterQuotaRecovery';
 const QUOTA_DEPLETED_DETAIL_KEY = 'virtualRouterQuotaDepleted';
 function parseDurationToMs(value) {
@@ -195,6 +196,46 @@ export function mapProviderErrorImpl(event, healthConfig) {
         }
     };
 }
+export function applySeriesCooldownImpl(event, providerRegistry, healthManager, markProviderCooldown, debug) {
+    const seriesDetail = extractSeriesCooldownDetail(event);
+    if (!seriesDetail) {
+        return;
+    }
+    const targetKeys = resolveSeriesCooldownTargets(seriesDetail, event, providerRegistry);
+    if (targetKeys.length === 0) {
+        debug?.log?.('[virtual-router] series cooldown skipped: no targets', {
+            providerId: seriesDetail.providerId,
+            providerKey: seriesDetail.providerKey,
+            series: seriesDetail.series
+        });
+        return;
+    }
+    const affected = [];
+    for (const providerKey of targetKeys) {
+        try {
+            const profile = providerRegistry.get(providerKey);
+            const modelSeries = resolveModelSeries(profile.modelId);
+            if (modelSeries !== seriesDetail.series) {
+                continue;
+            }
+            healthManager.tripProvider(providerKey, 'rate_limit', seriesDetail.cooldownMs);
+            markProviderCooldown(providerKey, seriesDetail.cooldownMs);
+            affected.push(providerKey);
+        }
+        catch {
+            // ignore lookup failures; invalid keys may show up if config drifted
+        }
+    }
+    if (affected.length) {
+        debug?.log?.('[virtual-router] series cooldown', {
+            providerId: seriesDetail.providerId,
+            providerKey: seriesDetail.providerKey,
+            series: seriesDetail.series,
+            cooldownMs: seriesDetail.cooldownMs,
+            affected
+        });
+    }
+}
 function extractQuotaRecoveryDetail(event) {
     if (!event || !event.details || typeof event.details !== 'object') {
         return null;
@@ -285,21 +326,63 @@ export function applyQuotaDepletedImpl(event, healthManager, markProviderCooldow
     }
     return true;
 }
-export function applySeriesCooldownImpl(event, _providerRegistry, _healthManager, _markProviderCooldown, debug) {
+function resolveSeriesCooldownTargets(detail, event, providerRegistry) {
+    const candidates = new Set();
+    const push = (key) => {
+        if (typeof key !== 'string') {
+            return;
+        }
+        const trimmed = key.trim();
+        if (!trimmed) {
+            return;
+        }
+        if (providerRegistry.has(trimmed)) {
+            candidates.add(trimmed);
+        }
+    };
+    push(detail.providerKey);
+    const runtimeKey = (event.runtime?.target && typeof event.runtime.target === 'object'
+        ? event.runtime.target.providerKey
+        : undefined) || event.runtime?.providerKey;
+    push(runtimeKey);
+    return Array.from(candidates);
+}
+function extractSeriesCooldownDetail(event) {
     if (!event || !event.details || typeof event.details !== 'object') {
-        return false;
+        return null;
     }
-    const raw = event.details.virtualRouterSeriesCooldown;
+    const raw = event.details[SERIES_COOLDOWN_DETAIL_KEY];
     if (!raw || typeof raw !== 'object') {
-        return false;
+        return null;
     }
-    const detail = raw;
-    debug?.log?.('[virtual-router] series cooldown ignored', {
-        providerId: detail.providerId,
-        series: detail.series,
-        cooldownMs: detail.cooldownMs
-    });
-    return true;
+    const record = raw;
+    const providerIdRaw = record.providerId;
+    const seriesRaw = record.series;
+    const providerKeyRaw = record.providerKey;
+    const cooldownRaw = record.cooldownMs;
+    if (typeof providerIdRaw !== 'string' || !providerIdRaw.trim()) {
+        return null;
+    }
+    const normalizedSeries = typeof seriesRaw === 'string' ? seriesRaw.trim().toLowerCase() : '';
+    if (normalizedSeries !== 'gemini-pro' && normalizedSeries !== 'gemini-flash' && normalizedSeries !== 'claude') {
+        return null;
+    }
+    const cooldownMs = typeof cooldownRaw === 'number'
+        ? cooldownRaw
+        : typeof cooldownRaw === 'string'
+            ? Number.parseFloat(cooldownRaw)
+            : Number.NaN;
+    if (!Number.isFinite(cooldownMs) || cooldownMs <= 0) {
+        return null;
+    }
+    return {
+        providerId: providerIdRaw.trim(),
+        ...(typeof providerKeyRaw === 'string' && providerKeyRaw.trim().length
+            ? { providerKey: providerKeyRaw.trim() }
+            : {}),
+        series: normalizedSeries,
+        cooldownMs: Math.round(cooldownMs)
+    };
 }
 export function deriveReason(code, stage, statusCode) {
     if (code.includes('RATE') || code.includes('429'))
@@ -318,3 +401,19 @@ export function deriveReason(code, stage, statusCode) {
         return 'client_error';
     return 'unknown';
 }
+function resolveModelSeries(modelId) {
+    if (!modelId) {
+        return 'default';
+    }
+    const lower = modelId.toLowerCase();
+    if (lower.includes('claude') || lower.includes('opus')) {
+        return 'claude';
+    }
+    if (lower.includes('flash')) {
+        return 'gemini-flash';
+    }
+    if (lower.includes('gemini') || lower.includes('pro')) {
+        return 'gemini-pro';
+    }
+    return 'default';
+}

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

@@ -13,18 +13,3 @@ export declare function pinCandidatesByAliasQueue(opts: {
     modelIdOfKey: (providerKey: string) => string | null;
     availabilityCheck: (providerKey: string) => boolean;
 }): string[] | null;
-export declare function pinCandidatesByBestQuota(opts: {
-    providerId: string;
-    modelId: string;
-    candidates: string[];
-    orderedTargets: string[];
-    aliasOfKey: (providerKey: string) => string | null;
-    modelIdOfKey: (providerKey: string) => string | null;
-    quotaView: ((providerKey: string) => {
-        remainingFraction?: number | null;
-        inPool: boolean;
-        cooldownUntil?: number | null;
-        blacklistUntil?: number | null;
-    } | null) | undefined;
-    now: number;
-}): string[] | null;

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

@@ -1,9 +1,8 @@
-const COOLDOWN_EMPTY_THRESHOLD_MS = 30_000;
 // Default provider-level strategy table.
 // This is a data-only default; callers can override via `loadBalancing.aliasSelection.providers`.
 export const DEFAULT_PROVIDER_ALIAS_SELECTION = {
-    // Antigravity: prefer the alias with highest remaining quota; fall back to sticky-queue when quota is unknown.
-    antigravity: 'best-quota'
+    // Antigravity: upstream gateway may reject rapid cross-key switching; stick to one alias until error.
+    antigravity: 'sticky-queue'
 };
 export function resolveAliasSelectionStrategy(providerId, cfg) {
     if (!providerId)
@@ -12,11 +11,11 @@ export function resolveAliasSelectionStrategy(providerId, cfg) {
         return 'none';
     const overrides = cfg?.providers ?? {};
     const override = overrides[providerId];
-    if (override === 'none' || override === 'sticky-queue' || override === 'best-quota') {
+    if (override === 'none' || override === 'sticky-queue') {
         return override;
     }
     const def = cfg?.defaultStrategy;
-    if (def === 'none' || def === 'sticky-queue' || def === 'best-quota') {
+    if (def === 'none' || def === 'sticky-queue') {
         return def;
     }
     const table = DEFAULT_PROVIDER_ALIAS_SELECTION[providerId];
@@ -101,86 +100,6 @@ export function pinCandidatesByAliasQueue(opts) {
     const selectedSet = new Set(selectedKeys);
     return candidates.filter((key) => selectedSet.has(key));
 }
-export function pinCandidatesByBestQuota(opts) {
-    const { providerId, modelId, candidates, orderedTargets, aliasOfKey, modelIdOfKey, quotaView, now } = opts;
-    if (!quotaView)
-        return null;
-    if (!providerId || !modelId)
-        return null;
-    if (!Array.isArray(candidates) || candidates.length < 2)
-        return null;
-    const aliasBuckets = new Map();
-    const aliasOrder = new Map();
-    let order = 0;
-    for (const key of candidates) {
-        if (!key || typeof key !== 'string')
-            continue;
-        if (!key.startsWith(`${providerId}.`))
-            return null;
-        const m = modelIdOfKey(key);
-        if (!m || m !== modelId)
-            return null;
-        const alias = aliasOfKey(key);
-        if (!alias)
-            return null;
-        const list = aliasBuckets.get(alias) ?? [];
-        list.push(key);
-        aliasBuckets.set(alias, list);
-        if (!aliasOrder.has(alias)) {
-            aliasOrder.set(alias, order++);
-        }
-    }
-    if (aliasBuckets.size <= 1)
-        return null;
-    const preferredOrder = resolveAliasOrderFromTargets({
-        orderedTargets,
-        providerId,
-        modelId,
-        aliasOfKey,
-        modelIdOfKey,
-        allowedAliases: new Set(aliasBuckets.keys())
-    });
-    for (const alias of preferredOrder) {
-        if (!aliasOrder.has(alias)) {
-            aliasOrder.set(alias, order++);
-        }
-    }
-    const eligible = [];
-    for (const [alias, keys] of aliasBuckets.entries()) {
-        const entry = quotaView(keys[0] ?? '');
-        if (!entry || entry.inPool === false) {
-            continue;
-        }
-        if (entry.blacklistUntil && entry.blacklistUntil > now) {
-            continue;
-        }
-        if (entry.cooldownUntil && entry.cooldownUntil - now >= COOLDOWN_EMPTY_THRESHOLD_MS) {
-            continue;
-        }
-        const remainingRaw = entry.remainingFraction;
-        const remaining = typeof remainingRaw === 'number' && Number.isFinite(remainingRaw) ? remainingRaw : 0;
-        if (remaining <= 0) {
-            continue;
-        }
-        eligible.push({
-            alias,
-            score: remaining,
-            order: aliasOrder.get(alias) ?? Number.MAX_SAFE_INTEGER
-        });
-    }
-    if (!eligible.length) {
-        return null;
-    }
-    eligible.sort((a, b) => (b.score - a.score) || (a.order - b.order));
-    const selectedAlias = eligible[0]?.alias;
-    if (!selectedAlias)
-        return null;
-    const selectedKeys = aliasBuckets.get(selectedAlias) ?? [];
-    if (!selectedKeys.length)
-        return null;
-    const selectedSet = new Set(selectedKeys);
-    return candidates.filter((key) => selectedSet.has(key));
-}
 function resolveAliasOrderFromTargets(opts) {
     const { orderedTargets, providerId, modelId, aliasOfKey, modelIdOfKey, allowedAliases } = opts;
     if (!Array.isArray(orderedTargets) || orderedTargets.length === 0) {

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

@@ -81,22 +81,16 @@ export function buildRouteCandidates(requestedRoute, classificationCandidates, f
     return filtered.length ? filtered : [DEFAULT_ROUTE];
 }
 export function extendRouteCandidatesForState(candidates, state, routing) {
-    // When provider allowlists are active (e.g. "<**!glm**>"), routing should not be bounded by
-    // classifier candidates only. Otherwise, a perfectly valid provider that exists in config
-    // (e.g. in a backup/default pool) can become unreachable and cause PROVIDER_NOT_AVAILABLE.
-    //
-    // We keep original ordering, then append all known routes (by priority) as a fallback search space.
+    // When provider allowlists are active (e.g. "<**!antigravity**>"),
+    // only look at the default pool. This keeps sticky semantics scoped
+    // to default routing, as required by RouteCodex.
     if (!state.allowedProviders || state.allowedProviders.size === 0) {
         return candidates;
     }
-    const allRoutes = sortByPriority(Object.keys(routing).filter((routeName) => routeName && routeHasTargets(routing[routeName])));
-    const expanded = Array.isArray(candidates) ? [...candidates] : [];
-    for (const routeName of allRoutes) {
-        if (!expanded.includes(routeName)) {
-            expanded.push(routeName);
-        }
+    if (routeHasTargets(routing[DEFAULT_ROUTE])) {
+        return [DEFAULT_ROUTE];
     }
-    return expanded;
+    return candidates;
 }
 function routeWeight(routeName) {
     const idx = ROUTE_PRIORITY.indexOf(routeName);

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

@@ -1,12 +1,11 @@
 import { computeContextMultiplier } from '../context-weighted.js';
 import { computeHealthWeight } from '../health-weighted.js';
-import { pinCandidatesByAliasQueue, pinCandidatesByBestQuota, resolveAliasSelectionStrategy } from './alias-selection.js';
+import { pinCandidatesByAliasQueue, resolveAliasSelectionStrategy } from './alias-selection.js';
 import { computeContextWeightMultipliers } from './context-weight-multipliers.js';
 import { extractKeyAlias, extractProviderId, getProviderModelId } from './key-parsing.js';
 import { pickPriorityGroup } from './tier-priority.js';
-const ANTIGRAVITY_COOLDOWN_ALIAS_THRESHOLD_MS = 30_000;
 function applyAliasStickyQueuePinning(opts) {
-    const { candidates, orderedTargets, deps, excludedKeys, now } = opts;
+    const { candidates, orderedTargets, deps, excludedKeys } = opts;
     if (!Array.isArray(candidates) || candidates.length < 2) {
         return candidates;
     }
@@ -27,7 +26,7 @@ function applyAliasStickyQueuePinning(opts) {
             continue;
         }
         const strategy = resolveAliasSelectionStrategy(providerId, deps.loadBalancer.getPolicy().aliasSelection);
-        if (strategy !== 'sticky-queue' && strategy !== 'best-quota') {
+        if (strategy !== 'sticky-queue') {
             continue;
         }
         const modelId = getProviderModelId(key, deps.providerRegistry) ?? '';
@@ -59,33 +58,17 @@ function applyAliasStickyQueuePinning(opts) {
         if (aliases.size < 2) {
             continue;
         }
-        const strategy = resolveAliasSelectionStrategy(group.providerId, deps.loadBalancer.getPolicy().aliasSelection);
-        let pinned = null;
-        if (strategy === 'best-quota') {
-            pinned = pinCandidatesByBestQuota({
-                providerId: group.providerId,
-                modelId: group.modelId,
-                candidates: group.keys,
-                orderedTargets,
-                aliasOfKey: extractKeyAlias,
-                modelIdOfKey: (key) => getProviderModelId(key, deps.providerRegistry),
-                quotaView: deps.quotaView,
-                now
-            });
-        }
-        if (!pinned) {
-            pinned = pinCandidatesByAliasQueue({
-                queueStore: store,
-                providerId: group.providerId,
-                modelId: group.modelId,
-                candidates: group.keys,
-                orderedTargets,
-                excludedProviderKeys: excludedKeys,
-                aliasOfKey: extractKeyAlias,
-                modelIdOfKey: (key) => getProviderModelId(key, deps.providerRegistry),
-                availabilityCheck: (key) => deps.healthManager.isAvailable(key)
-            });
-        }
+        const pinned = pinCandidatesByAliasQueue({
+            queueStore: store,
+            providerId: group.providerId,
+            modelId: group.modelId,
+            candidates: group.keys,
+            orderedTargets,
+            excludedProviderKeys: excludedKeys,
+            aliasOfKey: extractKeyAlias,
+            modelIdOfKey: (key) => getProviderModelId(key, deps.providerRegistry),
+            availabilityCheck: (key) => deps.healthManager.isAvailable(key)
+        });
         if (pinned && pinned.length) {
             pinnedByGroup.set(groupId, new Set(pinned));
         }
@@ -178,8 +161,7 @@ export function selectProviderKeyFromCandidatePool(opts) {
             candidates: retryPreferredCandidates,
             orderedTargets: tier.targets,
             deps,
-            excludedKeys,
-            now
+            excludedKeys
         });
         if (tier.mode === 'priority') {
             if (isRecoveryAttempt) {
@@ -258,11 +240,7 @@ export function selectProviderKeyFromCandidatePool(opts) {
             continue;
         }
         if (entry.cooldownUntil && entry.cooldownUntil > now) {
-            const providerId = extractProviderId(key) ?? '';
-            const cooldownMs = entry.cooldownUntil - now;
-            if (providerId !== 'antigravity' || cooldownMs >= ANTIGRAVITY_COOLDOWN_ALIAS_THRESHOLD_MS) {
-                continue;
-            }
+            continue;
         }
         if (entry.blacklistUntil && entry.blacklistUntil > now) {
             continue;
@@ -295,8 +273,7 @@ export function selectProviderKeyFromCandidatePool(opts) {
             candidates: bucketCandidates,
             orderedTargets: tier.targets,
             deps,
-            excludedKeys,
-            now
+            excludedKeys
         });
         const bucketPenaltyMap = {};
         for (const item of bucket) {