@jsonstudio/rcc 0.90.364 → 0.90.429

package/vendor/@jsonstudio/llms/dist/router/virtual-router/classifier.js

@@ -1,187 +0,0 @@
-import { DEFAULT_ROUTE, ROUTE_PRIORITY } from './types.js';
-const DEFAULT_LONG_CONTEXT_THRESHOLD = 180000;
-export class RoutingClassifier {
-    config;
-    constructor(config) {
-        this.config = {
-            longContextThresholdTokens: config.longContextThresholdTokens ?? DEFAULT_LONG_CONTEXT_THRESHOLD,
-            thinkingKeywords: normalizeList(config.thinkingKeywords, ['think step', 'analysis', 'reasoning']),
-            backgroundKeywords: normalizeList(config.backgroundKeywords, ['background', 'context dump'])
-        };
-    }
-    classify(features) {
-        const lastToolCategory = features.lastAssistantToolCategory;
-        const webSearchIntent = detectWebSearchIntent(features.userTextSample);
-        const localToolContinuation = lastToolCategory === 'read' ||
-            lastToolCategory === 'write' ||
-            lastToolCategory === 'search' ||
-            lastToolCategory === 'other';
-        const reachedLongContext = features.estimatedTokens >= (this.config.longContextThresholdTokens ?? DEFAULT_LONG_CONTEXT_THRESHOLD);
-        const latestMessageFromUser = features.latestMessageFromUser === true;
-        const thinkingContinuation = lastToolCategory === 'read';
-        const thinkingFromUser = latestMessageFromUser;
-        const thinkingFromRead = !thinkingFromUser && thinkingContinuation;
-        const codingContinuation = lastToolCategory === 'write';
-        const searchContinuation = lastToolCategory === 'search';
-        const toolsContinuation = lastToolCategory === 'other';
-        const hasToolActivity = features.hasTools || features.hasToolCallResponses;
-        const evaluationMap = {
-            multimodal: {
-                triggered: features.hasImageAttachment,
-                reason: 'multimodal:media-detected'
-            },
-            vision: {
-                triggered: features.hasImageAttachment,
-                reason: 'vision:media-detected'
-            },
-            thinking: {
-                triggered: thinkingFromUser || thinkingFromRead,
-                reason: thinkingFromUser ? 'thinking:user-input' : 'thinking:last-tool-read'
-            },
-            longcontext: {
-                triggered: reachedLongContext,
-                reason: 'longcontext:token-threshold'
-            },
-            coding: {
-                triggered: codingContinuation,
-                reason: 'coding:last-tool-write'
-            },
-            web_search: {
-                // web_search 仅由“当前请求”触发：
-                // - 用户输入命中联网搜索意图关键词。
-                // 不再使用工具声明或上一轮 websearch 续写来决定路由。
-                triggered: !localToolContinuation && webSearchIntent,
-                reason: 'web_search:intent-keyword'
-            },
-            search: {
-                // search 路由：仅在上一轮 assistant 使用 search 类工具时继续命中，
-                // 不因本轮是否声明 web_search 工具而改变路由。
-                triggered: searchContinuation,
-                reason: 'search:last-tool-search'
-            },
-            tools: {
-                // tools 路由：通用工具分支，包括首次声明的 web/search 工具。
-                // 若上一轮已明确归类为 search，则优先命中 search 路由，tools 仅作为兜底。
-                triggered: toolsContinuation || (!searchContinuation && hasToolActivity),
-                reason: toolsContinuation ? 'tools:last-tool-other' : 'tools:tool-request-detected'
-            },
-            background: {
-                triggered: containsKeywords(features.userTextSample, this.config.backgroundKeywords ?? []),
-                reason: 'background:keywords'
-            }
-        };
-        for (const routeName of ROUTE_PRIORITY) {
-            const evaluation = evaluationMap[routeName];
-            if (evaluation && evaluation.triggered) {
-                const candidates = this.ensureDefaultCandidate([routeName]);
-                return this.buildResult(routeName, evaluation.reason, evaluationMap, candidates);
-            }
-        }
-        const candidates = this.ensureDefaultCandidate([DEFAULT_ROUTE]);
-        return this.buildResult(DEFAULT_ROUTE, 'fallback:default', evaluationMap, candidates);
-    }
-    buildResult(routeName, chosenReason, evaluations, candidates) {
-        const diagnostics = Object.entries(evaluations)
-            .filter(([_, evaluation]) => evaluation.triggered)
-            .map(([_, evaluation]) => evaluation.reason);
-        const reasoningParts = [chosenReason, ...diagnostics.filter((reason) => reason !== chosenReason)];
-        return {
-            routeName,
-            confidence: 0.9,
-            reasoning: reasoningParts.join('|'),
-            fallback: routeName === DEFAULT_ROUTE,
-            candidates: candidates.length ? candidates : [DEFAULT_ROUTE]
-        };
-    }
-    ensureDefaultCandidate(routes) {
-        const deduped = routes.filter(Boolean);
-        if (!deduped.includes(DEFAULT_ROUTE)) {
-            deduped.push(DEFAULT_ROUTE);
-        }
-        return deduped;
-    }
-    orderRoutes(routes) {
-        const unique = Array.from(new Set(routes.filter(Boolean)));
-        return unique.sort((a, b) => this.routeWeight(a) - this.routeWeight(b));
-    }
-    routeWeight(route) {
-        const index = ROUTE_PRIORITY.indexOf(route);
-        return index >= 0 ? index : ROUTE_PRIORITY.length;
-    }
-}
-function detectWebSearchIntent(text) {
-    if (!text || !text.trim()) {
-        return false;
-    }
-    const normalized = text.toLowerCase();
-    if (isNegativeWebSearchContext(normalized, text)) {
-        return false;
-    }
-    const directKeywords = [
-        'web search',
-        'web_search',
-        'websearch',
-        'search the web',
-        'internet search',
-        '搜索网页',
-        '联网搜索',
-        '上网搜索',
-        '上网查',
-        '网上搜',
-        '谷歌搜索',
-        'google search'
-    ];
-    if (directKeywords.some((keyword) => normalized.includes(keyword))) {
-        return true;
-    }
-    const enVerb = ['search', 'find', 'lookup', 'look up', 'google'];
-    const enNoun = ['web', 'internet', 'online', 'google', 'bing'];
-    const hasEnVerb = enVerb.some((keyword) => normalized.includes(keyword));
-    const hasEnNoun = enNoun.some((keyword) => normalized.includes(keyword));
-    if (hasEnVerb && hasEnNoun) {
-        return true;
-    }
-    const zhVerb = ['搜索', '查找', '搜', '上网查', '上网搜', '联网查', '联网搜'];
-    const zhNoun = ['网络', '联网', '网页', '网上', '互联网', '谷歌', '百度'];
-    const hasZhVerb = zhVerb.some((keyword) => text.includes(keyword));
-    const hasZhNoun = zhNoun.some((keyword) => text.includes(keyword));
-    if ((text.includes('上网') || text.includes('联网')) && (text.includes('搜') || text.includes('查'))) {
-        return true;
-    }
-    if (hasZhVerb && hasZhNoun) {
-        return true;
-    }
-    return false;
-}
-function isNegativeWebSearchContext(normalized, originalText) {
-    const englishPatterns = [
-        /prefer\s+resources?\s+over\s+web[\s_-]?search/u,
-        /prefer[\s\S]{0,40}web[\s_-]?search/u,
-        /do\s+not[\s\S]{0,20}web[\s_-]?search/u,
-        /don't[\s\S]{0,20}web[\s_-]?search/u,
-        /without[\s\S]{0,20}web[\s_-]?search/u,
-        /cannot[\s\S]{0,20}web[\s_-]?search/u
-    ];
-    if (englishPatterns.some((pattern) => pattern.test(normalized))) {
-        return true;
-    }
-    const chinesePatterns = [
-        /不能.{0,20}(上网|联网|web[_ -]?search|搜索网页)/u,
-        /不要.{0,20}(上网|联网|web[_ -]?search|搜索网页)/u,
-        /避免.{0,20}(上网|联网|web[_ -]?search|搜索网页)/u
-    ];
-    return chinesePatterns.some((pattern) => pattern.test(originalText));
-}
-function normalizeList(source, fallback) {
-    if (!source || source.length === 0) {
-        return fallback;
-    }
-    return source.map((item) => item.toLowerCase());
-}
-function containsKeywords(text, keywords) {
-    if (!text || !keywords.length) {
-        return false;
-    }
-    const normalized = text.toLowerCase();
-    return keywords.some((keyword) => normalized.includes(keyword));
-}

package/vendor/@jsonstudio/llms/dist/router/virtual-router/context-advisor.d.ts

@@ -1,23 +0,0 @@
-import { type ProviderProfile, type VirtualRouterContextRoutingConfig } from './types.js';
-export interface ContextUsageSnapshot {
-    ratio: number;
-    limit: number;
-}
-export interface ContextAdvisorResult {
-    safe: string[];
-    risky: string[];
-    overflow: string[];
-    usage: Record<string, ContextUsageSnapshot>;
-    estimatedTokens: number;
-    allOverflow: boolean;
-}
-export declare class ContextAdvisor {
-    private warnRatio;
-    private hardLimit;
-    configure(config?: VirtualRouterContextRoutingConfig | null): void;
-    classify(pool: string[], estimatedTokens: number, resolveProfile: (key: string) => ProviderProfile): ContextAdvisorResult;
-    getConfig(): {
-        warnRatio: number;
-        hardLimit: boolean;
-    };
-}

package/vendor/@jsonstudio/llms/dist/router/virtual-router/context-advisor.js

@@ -1,67 +0,0 @@
-import { DEFAULT_MODEL_CONTEXT_TOKENS } from './types.js';
-const DEFAULT_WARN_RATIO = 0.9;
-export class ContextAdvisor {
-    warnRatio = DEFAULT_WARN_RATIO;
-    hardLimit = false;
-    configure(config) {
-        if (config && typeof config.warnRatio === 'number' && Number.isFinite(config.warnRatio)) {
-            this.warnRatio = clampWarnRatio(config.warnRatio);
-        }
-        else {
-            this.warnRatio = DEFAULT_WARN_RATIO;
-        }
-        this.hardLimit = Boolean(config?.hardLimit);
-    }
-    classify(pool, estimatedTokens, resolveProfile) {
-        const normalizedTokens = typeof estimatedTokens === 'number' && Number.isFinite(estimatedTokens) && estimatedTokens > 0
-            ? estimatedTokens
-            : 0;
-        const safe = [];
-        const risky = [];
-        const overflow = [];
-        const usage = {};
-        for (const providerKey of pool) {
-            let limit = DEFAULT_MODEL_CONTEXT_TOKENS;
-            try {
-                const profile = resolveProfile(providerKey);
-                if (profile?.maxContextTokens && Number.isFinite(profile.maxContextTokens)) {
-                    limit = profile.maxContextTokens;
-                }
-            }
-            catch {
-                limit = DEFAULT_MODEL_CONTEXT_TOKENS;
-            }
-            if (!limit || limit <= 0) {
-                limit = DEFAULT_MODEL_CONTEXT_TOKENS;
-            }
-            const ratio = limit > 0 ? normalizedTokens / limit : 0;
-            usage[providerKey] = { ratio, limit };
-            if (normalizedTokens === 0 || ratio < this.warnRatio) {
-                safe.push(providerKey);
-                continue;
-            }
-            if (ratio < 1) {
-                risky.push(providerKey);
-                continue;
-            }
-            overflow.push(providerKey);
-        }
-        return {
-            safe,
-            risky,
-            overflow,
-            usage,
-            estimatedTokens: normalizedTokens,
-            allOverflow: safe.length === 0 && risky.length === 0 && overflow.length > 0
-        };
-    }
-    getConfig() {
-        return { warnRatio: this.warnRatio, hardLimit: this.hardLimit };
-    }
-}
-function clampWarnRatio(value) {
-    if (!Number.isFinite(value)) {
-        return DEFAULT_WARN_RATIO;
-    }
-    return Math.max(0.1, Math.min(0.99, value));
-}

package/vendor/@jsonstudio/llms/dist/router/virtual-router/context-weighted.d.ts

@@ -1,31 +0,0 @@
-import type { ContextWeightedLoadBalancingConfig } from './types.js';
-export type ResolvedContextWeightedConfig = Required<{
-    enabled: boolean;
-    clientCapTokens: number;
-    gamma: number;
-    maxMultiplier: number;
-}>;
-/**
- * Context-weighted constant table (defaults).
- *
- * Intended behavior:
- * - Prefer smaller effective safe context windows early, so that larger windows remain available later.
- * - Compensation is proportional by default (`gamma=1`), but capped by `maxMultiplier`.
- *
- * Notes:
- * - `clientCapTokens` is the maximum effective context the client can consume, even if the model supports more.
- * - The effective safe window is computed using ContextAdvisor's `warnRatio` and model "slack" above the client cap.
- *   - If a model has slack >= the reserved margin, it effectively gets the full client cap as safe window.
- */
-export declare const DEFAULT_CONTEXT_WEIGHTED_CONFIG: ResolvedContextWeightedConfig;
-export declare function resolveContextWeightedConfig(raw?: ContextWeightedLoadBalancingConfig | null): ResolvedContextWeightedConfig;
-export declare function computeEffectiveSafeWindowTokens(options: {
-    modelMaxTokens: number;
-    warnRatio: number;
-    clientCapTokens: number;
-}): number;
-export declare function computeContextMultiplier(options: {
-    effectiveSafeRefTokens: number;
-    effectiveSafeTokens: number;
-    cfg: ResolvedContextWeightedConfig;
-}): number;

package/vendor/@jsonstudio/llms/dist/router/virtual-router/context-weighted.js

@@ -1,54 +0,0 @@
-/**
- * Context-weighted constant table (defaults).
- *
- * Intended behavior:
- * - Prefer smaller effective safe context windows early, so that larger windows remain available later.
- * - Compensation is proportional by default (`gamma=1`), but capped by `maxMultiplier`.
- *
- * Notes:
- * - `clientCapTokens` is the maximum effective context the client can consume, even if the model supports more.
- * - The effective safe window is computed using ContextAdvisor's `warnRatio` and model "slack" above the client cap.
- *   - If a model has slack >= the reserved margin, it effectively gets the full client cap as safe window.
- */
-export const DEFAULT_CONTEXT_WEIGHTED_CONFIG = {
-    enabled: false,
-    clientCapTokens: 200_000,
-    gamma: 1,
-    maxMultiplier: 2
-};
-export function resolveContextWeightedConfig(raw) {
-    const enabled = raw?.enabled ?? DEFAULT_CONTEXT_WEIGHTED_CONFIG.enabled;
-    const clientCapTokens = typeof raw?.clientCapTokens === 'number' && Number.isFinite(raw.clientCapTokens) && raw.clientCapTokens > 0
-        ? Math.floor(raw.clientCapTokens)
-        : DEFAULT_CONTEXT_WEIGHTED_CONFIG.clientCapTokens;
-    const gamma = typeof raw?.gamma === 'number' && Number.isFinite(raw.gamma) && raw.gamma > 0
-        ? raw.gamma
-        : DEFAULT_CONTEXT_WEIGHTED_CONFIG.gamma;
-    const maxMultiplier = typeof raw?.maxMultiplier === 'number' && Number.isFinite(raw.maxMultiplier) && raw.maxMultiplier >= 1
-        ? raw.maxMultiplier
-        : DEFAULT_CONTEXT_WEIGHTED_CONFIG.maxMultiplier;
-    return { enabled, clientCapTokens, gamma, maxMultiplier };
-}
-export function computeEffectiveSafeWindowTokens(options) {
-    const modelMaxTokens = typeof options.modelMaxTokens === 'number' && Number.isFinite(options.modelMaxTokens) && options.modelMaxTokens > 0
-        ? Math.floor(options.modelMaxTokens)
-        : 1;
-    const clientCapTokens = typeof options.clientCapTokens === 'number' && Number.isFinite(options.clientCapTokens) && options.clientCapTokens > 0
-        ? Math.floor(options.clientCapTokens)
-        : DEFAULT_CONTEXT_WEIGHTED_CONFIG.clientCapTokens;
-    const warnRatio = typeof options.warnRatio === 'number' && Number.isFinite(options.warnRatio) && options.warnRatio > 0 && options.warnRatio < 1
-        ? options.warnRatio
-        : 0.9;
-    const effectiveMax = Math.min(modelMaxTokens, clientCapTokens);
-    const reserve = Math.ceil(effectiveMax * (1 - warnRatio));
-    const slack = Math.max(0, modelMaxTokens - clientCapTokens);
-    const reserveEff = Math.max(0, reserve - slack);
-    return Math.max(1, effectiveMax - reserveEff);
-}
-export function computeContextMultiplier(options) {
-    const ref = Math.max(1, Math.floor(options.effectiveSafeRefTokens));
-    const cur = Math.max(1, Math.floor(options.effectiveSafeTokens));
-    const ratio = ref / cur;
-    const raw = Math.pow(Math.max(1, ratio), options.cfg.gamma);
-    return Math.min(options.cfg.maxMultiplier, raw);
-}

package/vendor/@jsonstudio/llms/dist/router/virtual-router/default-thinking-keywords.d.ts

@@ -1 +0,0 @@
-export declare const DEFAULT_THINKING_KEYWORDS: string[];

package/vendor/@jsonstudio/llms/dist/router/virtual-router/default-thinking-keywords.js

@@ -1,13 +0,0 @@
-export const DEFAULT_THINKING_KEYWORDS = [
-    '思考',
-    '深度思考',
-    '分析',
-    '推理',
-    '思路',
-    '一步一步',
-    '慢慢',
-    'think',
-    'thinking',
-    'step by step',
-    'reason'
-];

package/vendor/@jsonstudio/llms/dist/router/virtual-router/engine/antigravity/alias-lease.d.ts

@@ -1,33 +0,0 @@
-import type { RouterMetadataInput, VirtualRouterConfig } from '../../types.js';
-import type { ProviderRegistry } from '../../provider-registry.js';
-export type AntigravityAliasLeaseStore = Map<string, {
-    sessionKey: string;
-    lastSeenAt: number;
-}>;
-export type AntigravitySessionAliasStore = Map<string, string>;
-export type AntigravityLeasePersistenceState = {
-    loadedOnce: boolean;
-    loadedMtimeMs: number | null;
-    flushTimer: ReturnType<typeof setTimeout> | null;
-};
-export declare function resolveAntigravityAliasReuseCooldownMs(config: VirtualRouterConfig): number;
-export declare function hydrateAntigravityAliasLeaseStoreIfNeeded(options: {
-    force?: boolean;
-    leaseStore: AntigravityAliasLeaseStore;
-    persistence: AntigravityLeasePersistenceState;
-    aliasReuseCooldownMs: number;
-}): void;
-export declare function recordAntigravitySessionLease(options: {
-    metadata: RouterMetadataInput;
-    providerKey: string;
-    sessionKey: string | undefined;
-    providerRegistry: ProviderRegistry;
-    leaseStore: AntigravityAliasLeaseStore;
-    sessionAliasStore: AntigravitySessionAliasStore;
-    persistence: AntigravityLeasePersistenceState;
-    aliasReuseCooldownMs: number;
-    commitSessionBinding: boolean;
-    debug?: {
-        log?: (...args: any[]) => void;
-    };
-}): void;

package/vendor/@jsonstudio/llms/dist/router/virtual-router/engine/antigravity/alias-lease.js

@@ -1,257 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { resolveRccPath, resolveRccPathForRead } from '../../../../runtime/user-data-paths.js';
-export function resolveAntigravityAliasReuseCooldownMs(config) {
-    const cfg = config.loadBalancing?.aliasSelection?.sessionLeaseCooldownMs;
-    if (typeof cfg === 'number' && Number.isFinite(cfg)) {
-        return Math.max(0, Math.floor(cfg));
-    }
-    return 5 * 60_000;
-}
-function resolveAntigravityLeaseScope(providerRegistry, providerKey) {
-    try {
-        const profile = providerRegistry.get(providerKey);
-        const modelId = typeof profile?.modelId === 'string' ? profile.modelId.trim().toLowerCase() : '';
-        if (modelId.startsWith('gemini-')) {
-            return 'gemini';
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-function buildScopedSessionKey(sessionKey) {
-    return `${sessionKey}::gemini`;
-}
-function buildAntigravityLeaseRuntimeKey(runtimeKey) {
-    return `${runtimeKey}::gemini`;
-}
-function extractRuntimeKey(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 resolveAntigravityAliasLeasePersistWritePath() {
-    try {
-        const enabledRaw = process.env.ROUTECODEX_ANTIGRAVITY_ALIAS_LEASE_PERSIST;
-        const enabled = typeof enabledRaw === 'string' &&
-            ['1', 'true', 'yes', 'on'].includes(enabledRaw.trim().toLowerCase());
-        if (!enabled) {
-            return null;
-        }
-        return resolveRccPath('state', 'antigravity-alias-leases.json');
-    }
-    catch {
-        return null;
-    }
-}
-function resolveAntigravityAliasLeasePersistReadPath() {
-    try {
-        const writePath = resolveAntigravityAliasLeasePersistWritePath();
-        if (!writePath) {
-            return null;
-        }
-        const resolved = resolveRccPathForRead('state', 'antigravity-alias-leases.json');
-        return fs.existsSync(resolved) ? resolved : writePath;
-    }
-    catch {
-        return null;
-    }
-}
-export function hydrateAntigravityAliasLeaseStoreIfNeeded(options) {
-    const filePath = resolveAntigravityAliasLeasePersistReadPath();
-    if (!filePath) {
-        return;
-    }
-    const force = options.force === true;
-    let stat = null;
-    try {
-        stat = fs.statSync(filePath);
-    }
-    catch {
-        options.persistence.loadedOnce = true;
-        options.persistence.loadedMtimeMs = null;
-        return;
-    }
-    const mtimeMs = typeof stat.mtimeMs === 'number' && Number.isFinite(stat.mtimeMs) ? stat.mtimeMs : stat.mtime.getTime();
-    if (!force && options.persistence.loadedOnce && options.persistence.loadedMtimeMs === mtimeMs) {
-        return;
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-    }
-    catch {
-        options.persistence.loadedOnce = true;
-        options.persistence.loadedMtimeMs = mtimeMs;
-        return;
-    }
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        options.persistence.loadedOnce = true;
-        options.persistence.loadedMtimeMs = mtimeMs;
-        return;
-    }
-    const leasesRaw = parsed.leases;
-    if (!leasesRaw || typeof leasesRaw !== 'object' || Array.isArray(leasesRaw)) {
-        options.persistence.loadedOnce = true;
-        options.persistence.loadedMtimeMs = mtimeMs;
-        return;
-    }
-    const now = Date.now();
-    const cooldownMs = options.aliasReuseCooldownMs;
-    const nextLeaseStore = new Map();
-    for (const [runtimeKeyRaw, entryRaw] of Object.entries(leasesRaw)) {
-        const runtimeKeyBase = typeof runtimeKeyRaw === 'string' ? runtimeKeyRaw.trim() : '';
-        if (!runtimeKeyBase || !runtimeKeyBase.startsWith('antigravity.'))
-            continue;
-        if (!entryRaw || typeof entryRaw !== 'object' || Array.isArray(entryRaw))
-            continue;
-        const rawSessionKey = typeof entryRaw.sessionKey === 'string' ? String(entryRaw.sessionKey).trim() : '';
-        const lastSeenAt = typeof entryRaw.lastSeenAt === 'number' && Number.isFinite(entryRaw.lastSeenAt)
-            ? Math.floor(entryRaw.lastSeenAt)
-            : 0;
-        if (!rawSessionKey || !lastSeenAt)
-            continue;
-        if (cooldownMs > 0 && now - lastSeenAt >= cooldownMs)
-            continue;
-        // Backwards compatible: legacy lease keys were unscoped ("antigravity.<alias>").
-        // Policy: only keep Gemini-scoped leases. Drop any non-gemini scoped entries.
-        const hasExplicitScope = runtimeKeyBase.includes('::');
-        if (hasExplicitScope && !runtimeKeyBase.endsWith('::gemini'))
-            continue;
-        const runtimeKey = hasExplicitScope ? runtimeKeyBase : buildAntigravityLeaseRuntimeKey(runtimeKeyBase);
-        if (rawSessionKey.includes('::') && !rawSessionKey.endsWith('::gemini'))
-            continue;
-        const sessionKey = rawSessionKey.includes('::') ? rawSessionKey : buildScopedSessionKey(rawSessionKey);
-        nextLeaseStore.set(runtimeKey, { sessionKey, lastSeenAt });
-    }
-    options.leaseStore.clear();
-    for (const [key, val] of nextLeaseStore.entries()) {
-        options.leaseStore.set(key, val);
-    }
-    options.persistence.loadedOnce = true;
-    options.persistence.loadedMtimeMs = mtimeMs;
-}
-function flushAntigravityAliasLeaseStoreSync(options) {
-    const filePath = resolveAntigravityAliasLeasePersistWritePath();
-    if (!filePath) {
-        return;
-    }
-    try {
-        fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    }
-    catch {
-        // ignore
-    }
-    const now = Date.now();
-    const cooldownMs = options.aliasReuseCooldownMs;
-    const leases = {};
-    for (const [runtimeKey, entry] of options.leaseStore.entries()) {
-        if (!runtimeKey || !entry)
-            continue;
-        if (cooldownMs > 0 && now - entry.lastSeenAt >= cooldownMs)
-            continue;
-        if (!entry.sessionKey || !entry.lastSeenAt)
-            continue;
-        leases[runtimeKey] = { sessionKey: entry.sessionKey, lastSeenAt: entry.lastSeenAt };
-    }
-    try {
-        const tmpPath = `${filePath}.tmp.${process.pid}.${now}`;
-        fs.writeFileSync(tmpPath, JSON.stringify({ version: 1, updatedAt: now, leases }, null, 2), 'utf8');
-        fs.renameSync(tmpPath, filePath);
-        try {
-            const stat = fs.statSync(filePath);
-            const mtimeMs = typeof stat.mtimeMs === 'number' && Number.isFinite(stat.mtimeMs) ? stat.mtimeMs : stat.mtime.getTime();
-            options.persistence.loadedOnce = true;
-            options.persistence.loadedMtimeMs = mtimeMs;
-        }
-        catch {
-            // ignore
-        }
-    }
-    catch {
-        // best-effort persistence: must not affect routing
-    }
-}
-function scheduleAntigravityAliasLeaseStoreFlush(options) {
-    if (options.persistence.flushTimer) {
-        return;
-    }
-    options.persistence.flushTimer = setTimeout(() => {
-        options.persistence.flushTimer = null;
-        flushAntigravityAliasLeaseStoreSync(options);
-    }, 250);
-    options.persistence.flushTimer.unref?.();
-}
-export function recordAntigravitySessionLease(options) {
-    // Per-request runtime override: allow callers (e.g. servertool followups) to disable
-    // Antigravity gemini session binding/lease without changing global config.
-    try {
-        const rt = options.metadata?.__rt;
-        if (rt && typeof rt === 'object' && !Array.isArray(rt)) {
-            const disable = rt.disableAntigravitySessionBinding;
-            const mode = rt.antigravitySessionBinding;
-            if (disable === true || mode === false) {
-                return;
-            }
-            if (typeof mode === 'string' && ['0', 'false', 'off', 'disabled', 'none'].includes(mode.trim().toLowerCase())) {
-                return;
-            }
-        }
-    }
-    catch {
-        // ignore metadata parse errors
-    }
-    const sessionKey = options.sessionKey;
-    if (!sessionKey) {
-        return;
-    }
-    const runtimeKeyBase = extractRuntimeKey(options.providerKey);
-    if (!runtimeKeyBase || !runtimeKeyBase.startsWith('antigravity.')) {
-        return;
-    }
-    // Policy: antigravity alias leasing/binding applies only to Gemini models.
-    const scope = resolveAntigravityLeaseScope(options.providerRegistry, options.providerKey);
-    if (scope !== 'gemini') {
-        return;
-    }
-    const scopedSessionKey = buildScopedSessionKey(sessionKey);
-    const runtimeKey = buildAntigravityLeaseRuntimeKey(runtimeKeyBase);
-    const now = Date.now();
-    const cooldownMs = options.aliasReuseCooldownMs;
-    const existing = options.leaseStore.get(runtimeKey);
-    // Do not steal a lease from another active session. This prevents a "forced fallback" route
-    // (e.g. default route bypass) from evicting the original session and causing churn.
-    if (existing && existing.sessionKey !== scopedSessionKey && cooldownMs > 0 && now - existing.lastSeenAt < cooldownMs) {
-        return;
-    }
-    options.leaseStore.set(runtimeKey, { sessionKey: scopedSessionKey, lastSeenAt: now });
-    scheduleAntigravityAliasLeaseStoreFlush(options);
-    if (!options.commitSessionBinding) {
-        return;
-    }
-    // Bind sessionKey → alias runtimeKey so subsequent routing will prefer this alias.
-    options.sessionAliasStore.set(scopedSessionKey, runtimeKey);
-    try {
-        options.debug?.log?.('[virtual-router][antigravity-session-binding] commit', {
-            sessionKey: scopedSessionKey,
-            runtimeKey,
-            prev: existing?.sessionKey ?? null
-        });
-    }
-    catch {
-        // ignore
-    }
-}