@jsonstudio/rcc 0.90.323 → 0.90.364

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

@@ -0,0 +1,187 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,54 @@
+/**
+ * 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

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

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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,257 @@
+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
+    }
+}