@jsonstudio/llms 0.6.2172 → 0.6.2979

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

@@ -0,0 +1,16 @@
+import type { AliasSelectionConfig, AliasSelectionStrategy } from '../types.js';
+type NativeAliasQueuePinPayload = {
+    queue: string[];
+    desiredOrder: string[];
+    excludedAliases: string[];
+    aliasBuckets: Record<string, string[]>;
+    candidateOrder: string[];
+    availabilityByAlias: Record<string, boolean>;
+};
+type NativeAliasQueuePinOutput = {
+    queue: string[];
+    selectedCandidates: string[];
+};
+export declare function resolveAliasSelectionStrategyWithNative(providerId: string, cfg: AliasSelectionConfig | undefined): AliasSelectionStrategy;
+export declare function pinAliasQueueWithNative(payload: NativeAliasQueuePinPayload): NativeAliasQueuePinOutput;
+export {};

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

@@ -0,0 +1,96 @@
+import { failNativeRequired } from './native-router-hotpath-policy.js';
+import { loadNativeRouterHotpathBindingForInternalUse } from './native-router-hotpath.js';
+function readNativeFunction(name) {
+    const binding = loadNativeRouterHotpathBindingForInternalUse();
+    const fn = binding?.[name];
+    return typeof fn === 'function' ? fn : null;
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseAliasSelectionStrategy(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed === 'none' || parsed === 'sticky-queue') {
+            return parsed;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function parseAliasQueuePinOutput(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return null;
+        }
+        const row = parsed;
+        if (!Array.isArray(row.queue) || !Array.isArray(row.selectedCandidates)) {
+            return null;
+        }
+        const queue = row.queue.filter((v) => typeof v === 'string');
+        const selectedCandidates = row.selectedCandidates.filter((v) => typeof v === 'string');
+        return {
+            queue,
+            selectedCandidates
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function resolveAliasSelectionStrategyWithNative(providerId, cfg) {
+    const capability = 'resolveAliasSelectionStrategyJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    const fn = readNativeFunction('resolveAliasSelectionStrategyJson');
+    if (!fn) {
+        return fail();
+    }
+    const cfgJson = safeStringify(cfg ?? null);
+    if (!cfgJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(String(providerId || ''), cfgJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseAliasSelectionStrategy(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function pinAliasQueueWithNative(payload) {
+    const capability = 'pinAliasQueueJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    const fn = readNativeFunction('pinAliasQueueJson');
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify(payload);
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseAliasQueuePinOutput(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}

package/dist/router/virtual-router/engine-selection/native-virtual-router-stop-message-actions-semantics.d.ts

@@ -0,0 +1,6 @@
+export type NativeStopMessageActionPatch = {
+    applied: boolean;
+    set: Record<string, unknown>;
+    unset: string[];
+};
+export declare function applyStopMessageInstructionWithNative(instruction: unknown, state: unknown, nowMs: number): NativeStopMessageActionPatch;

package/dist/router/virtual-router/engine-selection/native-virtual-router-stop-message-actions-semantics.js

@@ -0,0 +1,85 @@
+import { failNativeRequired } from './native-router-hotpath-policy.js';
+import { loadNativeRouterHotpathBindingForInternalUse } from './native-router-hotpath.js';
+const STOP_MESSAGE_FIELDS = new Set([
+    'stopMessageSource',
+    'stopMessageText',
+    'stopMessageMaxRepeats',
+    'stopMessageUsed',
+    'stopMessageUpdatedAt',
+    'stopMessageLastUsedAt',
+    'stopMessageStageMode',
+    'stopMessageAiMode',
+    'stopMessageAiSeedPrompt',
+    'stopMessageAiHistory'
+]);
+function readNativeFunction(name) {
+    const binding = loadNativeRouterHotpathBindingForInternalUse();
+    const fn = binding?.[name];
+    return typeof fn === 'function' ? fn : null;
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseActionPatchPayload(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return null;
+        }
+        const row = parsed;
+        if (typeof row.applied !== 'boolean') {
+            return null;
+        }
+        const setRaw = row.set;
+        const unsetRaw = row.unset;
+        const normalizedSet = {};
+        if (setRaw && typeof setRaw === 'object' && !Array.isArray(setRaw)) {
+            for (const [key, value] of Object.entries(setRaw)) {
+                if (value !== undefined) {
+                    normalizedSet[key] = value;
+                }
+            }
+        }
+        const normalizedUnset = Array.isArray(unsetRaw)
+            ? unsetRaw.filter((key) => typeof key === 'string')
+            : [];
+        return {
+            applied: row.applied,
+            set: normalizedSet,
+            unset: Array.from(new Set(normalizedUnset))
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function applyStopMessageInstructionWithNative(instruction, state, nowMs) {
+    const capability = 'applyStopMessageInstructionJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const instructionJson = safeStringify(instruction);
+    const stateJson = safeStringify(state);
+    if (!instructionJson || !stateJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const result = fn(instructionJson, stateJson, Math.floor(nowMs));
+        if (typeof result !== 'string' || !result) {
+            return fail('empty result');
+        }
+        const parsed = parseActionPatchPayload(result);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}

package/dist/router/virtual-router/engine-selection/native-virtual-router-stop-message-semantics.d.ts

@@ -0,0 +1,9 @@
+export type StopMessageNativeParseOutput = {
+    kind: 'clear';
+} | {
+    kind: 'set';
+    text: string;
+    maxRepeats: number;
+    aiMode?: 'on' | 'off';
+};
+export declare function parseStopMessageInstructionWithNative(instruction: string): StopMessageNativeParseOutput | null;

package/dist/router/virtual-router/engine-selection/native-virtual-router-stop-message-semantics.js

@@ -0,0 +1,70 @@
+import { failNativeRequired } from './native-router-hotpath-policy.js';
+import { loadNativeRouterHotpathBindingForInternalUse } from './native-router-hotpath.js';
+function readNativeFunction(name) {
+    const binding = loadNativeRouterHotpathBindingForInternalUse();
+    const fn = binding?.[name];
+    return typeof fn === 'function' ? fn : null;
+}
+function normalizeMode(value) {
+    if (value !== 'on' && value !== 'off') {
+        return undefined;
+    }
+    return value;
+}
+function parseStopMessageNativePayload(raw) {
+    let parsed = null;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        return null;
+    }
+    const kindRaw = parsed.kind;
+    if (kindRaw !== 'set' && kindRaw !== 'clear') {
+        return null;
+    }
+    const kind = kindRaw;
+    if (kind === 'clear') {
+        return { kind: 'clear' };
+    }
+    const text = typeof parsed.text === 'string' ? parsed.text : '';
+    const maxRepeats = typeof parsed.maxRepeats === 'number' && Number.isFinite(parsed.maxRepeats)
+        ? Math.floor(parsed.maxRepeats)
+        : 10;
+    if (!text || maxRepeats <= 0) {
+        return null;
+    }
+    const aiMode = normalizeMode(parsed.aiMode);
+    return {
+        kind: 'set',
+        text,
+        maxRepeats,
+        ...(aiMode ? { aiMode } : {})
+    };
+}
+export function parseStopMessageInstructionWithNative(instruction) {
+    const capability = 'parseStopMessageInstructionJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    const fn = readNativeFunction('parseStopMessageInstructionJson');
+    if (!fn) {
+        return fail();
+    }
+    try {
+        const result = fn(String(instruction || ''));
+        if (typeof result !== 'string') {
+            return fail('non-string result');
+        }
+        if (!result || result === 'null') {
+            return null;
+        }
+        const parsed = parseStopMessageNativePayload(result);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}

package/dist/router/virtual-router/engine-selection/native-virtual-router-stop-message-state-semantics.d.ts

@@ -0,0 +1,2 @@
+export declare function serializeStopMessageStateWithNative(state: unknown): Record<string, unknown>;
+export declare function deserializeStopMessageStateWithNative(data: Record<string, unknown>, state: unknown): Record<string, unknown>;

package/dist/router/virtual-router/engine-selection/native-virtual-router-stop-message-state-semantics.js

@@ -0,0 +1,76 @@
+import { failNativeRequired } from './native-router-hotpath-policy.js';
+import { loadNativeRouterHotpathBindingForInternalUse } from './native-router-hotpath.js';
+function readNativeFunction(name) {
+    const binding = loadNativeRouterHotpathBindingForInternalUse();
+    const fn = binding?.[name];
+    return typeof fn === 'function' ? fn : null;
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseRecordPayload(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export function serializeStopMessageStateWithNative(state) {
+    const capability = 'serializeStopMessageStateJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const stateJson = safeStringify(state);
+    if (!stateJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const result = fn(stateJson);
+        if (typeof result !== 'string' || !result) {
+            return fail('empty result');
+        }
+        const parsed = parseRecordPayload(result);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function deserializeStopMessageStateWithNative(data, state) {
+    const capability = 'deserializeStopMessageStateJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const dataJson = safeStringify(data);
+    const stateJson = safeStringify(state);
+    if (!dataJson || !stateJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const result = fn(dataJson, stateJson);
+        if (typeof result !== 'string' || !result) {
+            return fail('empty result');
+        }
+        const parsed = parseRecordPayload(result);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}

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

@@ -63,7 +63,7 @@ export function buildRouteCandidates(requestedRoute, classificationCandidates, f
                 baseList.unshift('multimodal');
             }
         }
-        if (hasVisionTargets) {
+        if (hasVisionTargets && (!hasMultimodalTargets || forceVision)) {
             if (!baseList.includes('vision')) {
                 baseList.push('vision');
             }

package/dist/router/virtual-router/engine-selection/tier-selection-antigravity-session-lease.d.ts

@@ -0,0 +1,10 @@
+import type { SelectionDeps } from './selection-deps.js';
+export declare function isAntigravityGeminiModelKey(providerKey: string, deps: SelectionDeps): boolean;
+export declare function extractLeaseRuntimeKey(providerKey: string, deps: SelectionDeps): string | null;
+export declare function applyAntigravityAliasSessionLeases(targets: string[], deps: SelectionDeps, metadata: unknown): {
+    targets: string[];
+    blocked: number;
+    preferredPinned: boolean;
+    pinnedStrict: boolean;
+    preferredRuntimeKey?: string;
+};

package/dist/router/virtual-router/engine-selection/tier-selection-antigravity-session-lease.js

@@ -0,0 +1,231 @@
+import { getProviderModelId, extractProviderId } from './key-parsing.js';
+import { lookupAntigravityPinnedAliasForSessionIdWithNative, unpinAntigravitySessionAliasForSessionIdWithNative } from './native-router-hotpath.js';
+import { lookupAntigravityPinnedAliasForSessionId, unpinAntigravitySessionAliasForSessionId } from '../../../conversion/compat/antigravity-session-signature.js';
+const DEFAULT_ANTIGRAVITY_ALIAS_SESSION_COOLDOWN_MS = 5 * 60_000;
+export function isAntigravityGeminiModelKey(providerKey, deps) {
+    if ((extractProviderId(providerKey) ?? '') !== 'antigravity') {
+        return false;
+    }
+    const modelId = getProviderModelId(providerKey, deps.providerRegistry) ?? '';
+    return modelId.trim().toLowerCase().startsWith('gemini-');
+}
+function extractAntigravityRuntimeBase(providerKey) {
+    const value = typeof providerKey === 'string' ? providerKey.trim() : '';
+    if (!value)
+        return null;
+    const firstDot = value.indexOf('.');
+    if (firstDot <= 0 || firstDot === value.length - 1)
+        return null;
+    const secondDot = value.indexOf('.', firstDot + 1);
+    if (secondDot <= firstDot + 1)
+        return null;
+    const providerId = value.slice(0, firstDot);
+    const alias = value.slice(firstDot + 1, secondDot);
+    if (!providerId || !alias)
+        return null;
+    return `${providerId}.${alias}`;
+}
+function buildAntigravityLeaseRuntimeKey(runtimeBase) {
+    return `${runtimeBase}::gemini`;
+}
+function isAntigravityGeminiSessionBindingDisabled(metadata) {
+    if (!metadata || typeof metadata !== 'object') {
+        return false;
+    }
+    const rtRaw = metadata.__rt;
+    if (!rtRaw || typeof rtRaw !== 'object' || Array.isArray(rtRaw)) {
+        return false;
+    }
+    const rt = rtRaw;
+    if (rt.disableAntigravitySessionBinding === true) {
+        return true;
+    }
+    const mode = rt.antigravitySessionBinding;
+    if (mode === false) {
+        return true;
+    }
+    if (typeof mode === 'string' && ['0', 'false', 'off', 'disabled', 'none'].includes(mode.trim().toLowerCase())) {
+        return true;
+    }
+    return false;
+}
+function resolveSessionScopeKey(metadata) {
+    if (!metadata || typeof metadata !== 'object') {
+        return null;
+    }
+    const record = metadata;
+    const sessionId = typeof record.sessionId === 'string' ? record.sessionId.trim() : '';
+    if (sessionId) {
+        return `session:${sessionId}`;
+    }
+    const conversationId = typeof record.conversationId === 'string' ? record.conversationId.trim() : '';
+    if (conversationId) {
+        return `conversation:${conversationId}`;
+    }
+    const antigravitySessionId = typeof record.antigravitySessionId === 'string'
+        ? String(record.antigravitySessionId).trim()
+        : '';
+    if (antigravitySessionId) {
+        return `session:${antigravitySessionId}`;
+    }
+    return null;
+}
+function buildScopedSessionKey(sessionKey) {
+    return `${sessionKey}::gemini`;
+}
+export function extractLeaseRuntimeKey(providerKey, deps) {
+    const base = extractAntigravityRuntimeBase(providerKey);
+    if (!base)
+        return null;
+    if ((extractProviderId(providerKey) ?? '') !== 'antigravity')
+        return base;
+    if (!isAntigravityGeminiModelKey(providerKey, deps)) {
+        return null;
+    }
+    return buildAntigravityLeaseRuntimeKey(base);
+}
+export function applyAntigravityAliasSessionLeases(targets, deps, metadata) {
+    if (!Array.isArray(targets) || targets.length === 0) {
+        return { targets, blocked: 0, preferredPinned: false, pinnedStrict: false };
+    }
+    if (isAntigravityGeminiSessionBindingDisabled(metadata)) {
+        return { targets, blocked: 0, preferredPinned: false, pinnedStrict: false };
+    }
+    const leaseStore = deps.antigravityAliasLeaseStore;
+    const sessionAliasStore = deps.antigravitySessionAliasStore;
+    if (!leaseStore || !sessionAliasStore) {
+        return { targets, blocked: 0, preferredPinned: false, pinnedStrict: false };
+    }
+    const sessionKey = resolveSessionScopeKey(metadata);
+    if (!sessionKey) {
+        return { targets, blocked: 0, preferredPinned: false, pinnedStrict: false };
+    }
+    const cooldownMs = typeof deps.antigravityAliasReuseCooldownMs === 'number' && Number.isFinite(deps.antigravityAliasReuseCooldownMs)
+        ? Math.max(0, Math.floor(deps.antigravityAliasReuseCooldownMs))
+        : DEFAULT_ANTIGRAVITY_ALIAS_SESSION_COOLDOWN_MS;
+    const now = Date.now();
+    const bindingModeRaw = deps.loadBalancer.getPolicy().aliasSelection
+        ?.antigravitySessionBinding;
+    const strictRequested = typeof bindingModeRaw === 'string' && bindingModeRaw.trim().toLowerCase() === 'strict';
+    const agSessionId = metadata && typeof metadata === 'object' && typeof metadata.antigravitySessionId === 'string'
+        ? String(metadata.antigravitySessionId).trim()
+        : '';
+    const hasAntigravityGeminiTargets = targets.some((key) => isAntigravityGeminiModelKey(key, deps));
+    const lookupPinnedRuntimeKey = () => {
+        if (!(strictRequested && agSessionId && hasAntigravityGeminiTargets)) {
+            return undefined;
+        }
+        const nativePinned = lookupAntigravityPinnedAliasForSessionIdWithNative(agSessionId, { hydrate: true });
+        if (nativePinned && nativePinned.trim()) {
+            return nativePinned.trim();
+        }
+        const persistedPinned = lookupAntigravityPinnedAliasForSessionId(agSessionId, { hydrate: true });
+        if (!persistedPinned || !persistedPinned.trim()) {
+            return undefined;
+        }
+        return persistedPinned.trim();
+    };
+    let pinnedRuntimeKey = lookupPinnedRuntimeKey();
+    const pinnedLeaseKey = pinnedRuntimeKey ? buildAntigravityLeaseRuntimeKey(pinnedRuntimeKey) : undefined;
+    if (pinnedRuntimeKey && deps.quotaView && agSessionId) {
+        const pinnedKeys = targets.filter((key) => isAntigravityGeminiModelKey(key, deps) && extractLeaseRuntimeKey(key, deps) === pinnedLeaseKey);
+        if (pinnedKeys.length > 0) {
+            const allOutOfPool = pinnedKeys.every((key) => deps.quotaView?.(key)?.inPool === false);
+            if (allOutOfPool) {
+                const releasedRuntimeKey = pinnedRuntimeKey;
+                unpinAntigravitySessionAliasForSessionIdWithNative(agSessionId);
+                unpinAntigravitySessionAliasForSessionId(agSessionId);
+                pinnedRuntimeKey = undefined;
+                sessionAliasStore.delete(buildScopedSessionKey(sessionKey));
+                try {
+                    const raw = String(process.env.ROUTECODEX_STAGE_LOG || process.env.RCC_STAGE_LOG || '').trim().toLowerCase();
+                    const enabled = raw !== '' && raw !== '0' && raw !== 'false' && raw !== 'no';
+                    if (enabled) {
+                        console.log('[virtual-router][antigravity-session-binding] unpin', JSON.stringify({ agSessionId, runtimeKey: releasedRuntimeKey }));
+                    }
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+    }
+    const strictBinding = strictRequested && Boolean(pinnedLeaseKey);
+    const geminiSessionKey = buildScopedSessionKey(sessionKey);
+    let preferredGeminiRuntimeKey = pinnedLeaseKey || sessionAliasStore.get(geminiSessionKey);
+    if (preferredGeminiRuntimeKey && !preferredGeminiRuntimeKey.includes('::')) {
+        preferredGeminiRuntimeKey = buildAntigravityLeaseRuntimeKey(preferredGeminiRuntimeKey);
+    }
+    if (preferredGeminiRuntimeKey && !pinnedLeaseKey) {
+        const lease = leaseStore.get(preferredGeminiRuntimeKey);
+        if (lease && lease.sessionKey !== geminiSessionKey && now - lease.lastSeenAt < cooldownMs) {
+            preferredGeminiRuntimeKey = undefined;
+        }
+    }
+    if (deps.quotaView && !pinnedLeaseKey && preferredGeminiRuntimeKey) {
+        const pinnedKeys = targets.filter((key) => isAntigravityGeminiModelKey(key, deps) && extractLeaseRuntimeKey(key, deps) === preferredGeminiRuntimeKey);
+        if (pinnedKeys.length > 0) {
+            const allOutOfPool = pinnedKeys.every((key) => deps.quotaView?.(key)?.inPool === false);
+            if (allOutOfPool) {
+                const releasedRuntimeKey = preferredGeminiRuntimeKey;
+                sessionAliasStore.delete(geminiSessionKey);
+                preferredGeminiRuntimeKey = undefined;
+                try {
+                    const raw = String(process.env.ROUTECODEX_STAGE_LOG || process.env.RCC_STAGE_LOG || '').trim().toLowerCase();
+                    const enabled = raw !== '' && raw !== '0' && raw !== 'false' && raw !== 'no';
+                    if (enabled) {
+                        console.log('[virtual-router][antigravity-session-binding] release', JSON.stringify({ sessionKey: geminiSessionKey, runtimeKey: releasedRuntimeKey }));
+                    }
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+    }
+    const pinnedGemini = preferredGeminiRuntimeKey
+        ? targets.filter((key) => isAntigravityGeminiModelKey(key, deps) && extractLeaseRuntimeKey(key, deps) === preferredGeminiRuntimeKey)
+        : [];
+    const preferredPinned = pinnedGemini.length > 0;
+    const pinnedSet = preferredPinned ? new Set([...pinnedGemini]) : null;
+    const candidates = preferredPinned
+        ? [...pinnedGemini, ...targets.filter((key) => !pinnedSet.has(key))]
+        : targets;
+    const pinnedStrict = strictBinding && Boolean(preferredGeminiRuntimeKey);
+    let blocked = 0;
+    const filtered = candidates.filter((key) => {
+        const providerId = extractProviderId(key);
+        if (providerId !== 'antigravity') {
+            return true;
+        }
+        if (!isAntigravityGeminiModelKey(key, deps)) {
+            return true;
+        }
+        const scopedSessionKey = geminiSessionKey;
+        const runtimeKey = extractLeaseRuntimeKey(key, deps);
+        if (!runtimeKey) {
+            return true;
+        }
+        if (pinnedStrict) {
+            if (!isAntigravityGeminiModelKey(key, deps)) {
+                return true;
+            }
+            if (preferredGeminiRuntimeKey && runtimeKey !== preferredGeminiRuntimeKey) {
+                return false;
+            }
+        }
+        const lease = leaseStore.get(runtimeKey);
+        if (!lease) {
+            return true;
+        }
+        if (lease.sessionKey === scopedSessionKey) {
+            return true;
+        }
+        if (now - lease.lastSeenAt >= cooldownMs) {
+            return true;
+        }
+        blocked += 1;
+        return false;
+    });
+    return { targets: filtered, blocked, preferredPinned, pinnedStrict, preferredRuntimeKey: preferredGeminiRuntimeKey };
+}

package/dist/router/virtual-router/engine-selection/tier-selection-antigravity-target-split.d.ts

@@ -0,0 +1,4 @@
+export declare function shouldAvoidAllAntigravityOnRetry(metadata: unknown): boolean;
+export declare function shouldAvoidAntigravityAfterRepeatedError(metadata: unknown): boolean;
+export declare function preferNonAntigravityWhenPossible(candidates: string[]): string[];
+export declare function extractNonAntigravityTargets(targets: string[]): string[];

package/dist/router/virtual-router/engine-selection/tier-selection-antigravity-target-split.js

@@ -0,0 +1,43 @@
+import { splitAntigravityTargets } from './native-router-hotpath.js';
+export function shouldAvoidAllAntigravityOnRetry(metadata) {
+    if (!metadata || typeof metadata !== 'object') {
+        return false;
+    }
+    const rtRaw = metadata.__rt;
+    if (!rtRaw || typeof rtRaw !== 'object' || Array.isArray(rtRaw)) {
+        return false;
+    }
+    const rt = rtRaw;
+    return rt.antigravityAvoidAllOnRetry === true;
+}
+export function shouldAvoidAntigravityAfterRepeatedError(metadata) {
+    if (!metadata || typeof metadata !== 'object') {
+        return false;
+    }
+    const rtRaw = metadata.__rt;
+    if (!rtRaw || typeof rtRaw !== 'object' || Array.isArray(rtRaw)) {
+        return false;
+    }
+    const rt = rtRaw;
+    if (rt.antigravityAvoidAllOnRetry === true) {
+        return true;
+    }
+    const signature = typeof rt.antigravityRetryErrorSignature === 'string' ? rt.antigravityRetryErrorSignature.trim() : '';
+    const consecutive = typeof rt.antigravityRetryErrorConsecutive === 'number' && Number.isFinite(rt.antigravityRetryErrorConsecutive)
+        ? Math.max(0, Math.floor(rt.antigravityRetryErrorConsecutive))
+        : 0;
+    return signature.length > 0 && signature !== 'unknown' && consecutive >= 2;
+}
+export function preferNonAntigravityWhenPossible(candidates) {
+    if (!Array.isArray(candidates) || candidates.length < 2) {
+        return candidates;
+    }
+    const nonAntigravity = splitAntigravityTargets(candidates).nonAntigravity;
+    return nonAntigravity.length > 0 ? nonAntigravity : candidates;
+}
+export function extractNonAntigravityTargets(targets) {
+    if (!Array.isArray(targets) || targets.length === 0) {
+        return [];
+    }
+    return splitAntigravityTargets(targets).nonAntigravity;
+}