@jsonstudio/llms 0.6.1449 → 0.6.1643

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

@@ -4,6 +4,9 @@ import { RouteLoadBalancer } from './load-balancer.js';
 import { RoutingClassifier } from './classifier.js';
 import { buildRoutingFeatures } from './features.js';
 import { ContextAdvisor } from './context-advisor.js';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
 import { DEFAULT_ROUTE, ROUTE_PRIORITY, VirtualRouterError, VirtualRouterErrorCode } from './types.js';
 import { getStatsCenter } from '../../telemetry/stats-center.js';
 import { parseRoutingInstructions, applyRoutingInstructions, cleanMessagesFromRoutingInstructions } from './routing-instructions.js';
@@ -25,6 +28,13 @@ export class VirtualRouterEngine {
     // Alias selection state (global within this VirtualRouterEngine instance).
     // Used by alias-selection strategies to avoid rapid cross-alias switching.
     aliasQueueStore = new Map();
+    // Antigravity alias session lease store:
+    // - Enforces that one auth alias is not shared across different sessions within a cooldown window.
+    // - Tracks lastSeenAt per alias runtimeKey (providerId.keyAlias).
+    antigravityAliasLeaseStore = new Map();
+    antigravitySessionAliasStore = new Map();
+    antigravityAliasReuseCooldownMs = 5 * 60_000;
+    antigravityLeasePersistence = { loadedOnce: false, loadedMtimeMs: null, flushTimer: null };
     debug = console; // thin hook; host may monkey-patch for colored logging
     healthConfig = null;
     statsCenter = getStatsCenter();
@@ -68,7 +78,19 @@ export class VirtualRouterEngine {
             this.routingInstructionState.clear();
         }
         if ('quotaView' in deps) {
+            const prevQuotaEnabled = Boolean(this.quotaView);
             this.quotaView = deps.quotaView ?? undefined;
+            const nextQuotaEnabled = Boolean(this.quotaView);
+            // When quotaView is enabled, health/cooldown decisions must be driven by quotaView only.
+            // - Enabling quotaView: clear any legacy router-local cooldown TTLs immediately.
+            // - Disabling quotaView: reload legacy cooldown state from health snapshots.
+            if (!prevQuotaEnabled && nextQuotaEnabled) {
+                this.providerCooldowns.clear();
+            }
+            else if (prevQuotaEnabled && !nextQuotaEnabled) {
+                this.providerCooldowns.clear();
+                this.restoreHealthFromStore();
+            }
         }
     }
     parseDirectProviderModel(model) {
@@ -100,6 +122,8 @@ export class VirtualRouterEngine {
         this.providerCooldowns.clear();
         this.restoreHealthFromStore();
         this.loadBalancer = new RouteLoadBalancer(config.loadBalancing);
+        this.antigravityAliasReuseCooldownMs = this.resolveAntigravityAliasReuseCooldownMs(config);
+        this.hydrateAntigravityAliasLeaseStoreIfNeeded(true);
         this.classifier = new RoutingClassifier(config.classifier);
         this.contextRouting = config.contextRouting ?? { warnRatio: 0.9, hardLimit: false };
         this.contextAdvisor.configure(this.contextRouting);
@@ -394,13 +418,13 @@ export class VirtualRouterEngine {
                     const quotaView = selectionDeps.quotaView;
                     const now = quotaView ? Date.now() : 0;
                     return candidateKeys.filter((key) => {
-                        if (this.isProviderCoolingDown(key)) {
-                            return false;
-                        }
-                        if (!this.healthManager.isAvailable(key)) {
-                            return false;
-                        }
                         if (!quotaView) {
+                            if (this.isProviderCoolingDown(key)) {
+                                return false;
+                            }
+                            if (!this.healthManager.isAvailable(key)) {
+                                return false;
+                            }
                             return true;
                         }
                         const entry = quotaView(key);
@@ -493,6 +517,7 @@ export class VirtualRouterEngine {
             ...(this.webSearchForce ? { forceWebSearch: true } : {}),
             ...(forceVision ? { forceVision: true } : {})
         };
+        this.recordAntigravitySessionLease(features.metadata, selection.providerKey, { commitSessionBinding: false });
         this.incrementRouteStat(selection.routeUsed, selection.providerKey);
         const routingMode = this.resolveRoutingMode([...metadataInstructions, ...instructions], routingState);
         try {
@@ -520,37 +545,6 @@ export class VirtualRouterEngine {
             this.debug?.log?.('[virtual-router-hit]', selection.routeUsed, selection.providerKey, target.modelId || '', hitReason ? `reason=${hitReason}` : '');
         }
         const didFallback = selection.routeUsed !== requestedRoute;
-        // 自动 sticky：对需要上下文 save/restore 的 Responses 会话，强制同一个 provider.key.model。
-        // 其它协议不启用粘滞，仅显式 routing 指令才会写入 stickyTarget。
-        const providerProtocol = metadata?.providerProtocol;
-        const serverToolRequired = metadata?.serverToolRequired === true;
-        const disableSticky = metadata &&
-            typeof metadata === 'object' &&
-            metadata.disableStickyRoutes === true;
-        const shouldAutoStickyForResponses = providerProtocol === 'openai-responses' && serverToolRequired && !disableSticky;
-        if (shouldAutoStickyForResponses) {
-            const stickyKeyForState = this.resolveStickyKey(metadata);
-            if (stickyKeyForState) {
-                const stateKey = stickyKeyForState;
-                const state = this.getRoutingInstructionState(stateKey);
-                if (!state.stickyTarget) {
-                    const providerId = this.extractProviderId(selection.providerKey);
-                    if (providerId) {
-                        const parts = selection.providerKey.split('.');
-                        const keyAlias = parts.length >= 3 ? parts[1] : undefined;
-                        const modelId = target.modelId;
-                        state.stickyTarget = {
-                            provider: providerId,
-                            keyAlias,
-                            model: modelId,
-                            // pathLength=3 表示 provider.key.model 形式，对应 alias 显式 sticky；
-                            // 若缺少别名或模型，则退化为更短 pathLength。
-                            pathLength: keyAlias && modelId ? 3 : keyAlias ? 2 : 1
-                        };
-                    }
-                }
-            }
-        }
         return {
             target,
             decision: {
@@ -623,15 +617,16 @@ export class VirtualRouterEngine {
                 // ignore persistence errors
             }
         }
-        // Antigravity account safety policy should apply even when quotaView is enabled.
-        // It uses router-local cooldown TTLs (not quotaView) to temporarily remove Antigravity from selection.
-        applyAntigravityRiskPolicyImpl(event, this.providerRegistry, this.healthManager, (key, ttl) => this.markProviderCooldown(key, ttl), this.debug);
+        // Quota routing mode: health/cooldown must be driven by quotaView only (host/core quota center).
+        // VirtualRouter must not produce or persist its own cooldown state in this mode.
         // 当 Host 注入 quotaView 时，VirtualRouter 的入池/优先级决策应以 quota 为准；
         // 此时不再在 engine-health 内部进行 429/backoff/series cooldown 等健康决策，
         // 以避免与 daemon/quota-center 的长期熔断策略重复维护并导致日志噪声。
         if (this.quotaView) {
             return;
         }
+        // Antigravity account safety policy uses router-local cooldown TTLs; only applies when quota routing is disabled.
+        applyAntigravityRiskPolicyImpl(event, this.providerRegistry, this.healthManager, (key, ttl) => this.markProviderCooldown(key, ttl), this.debug);
         // 配额恢复事件优先处理：一旦识别到 virtualRouterQuotaRecovery，
         // 直接清理健康状态/冷却 TTL，避免继续走常规错误映射逻辑。
         const handledByQuota = applyQuotaRecoveryImpl(event, this.healthManager, (key) => this.clearProviderCooldown(key), this.debug);
@@ -649,6 +644,24 @@ export class VirtualRouterEngine {
         }
         this.handleProviderFailure(derived);
     }
+    handleProviderSuccess(event) {
+        if (!event || typeof event !== 'object') {
+            return;
+        }
+        const providerKey = event.runtime && typeof event.runtime.providerKey === 'string' ? event.runtime.providerKey.trim() : '';
+        if (!providerKey) {
+            return;
+        }
+        const metadata = event.metadata && typeof event.metadata === 'object' && !Array.isArray(event.metadata)
+            ? event.metadata
+            : null;
+        if (!metadata) {
+            return;
+        }
+        if (providerKey.toLowerCase().startsWith('antigravity.')) {
+            this.recordAntigravitySessionLease(metadata, providerKey, { commitSessionBinding: true });
+        }
+    }
     getStatus() {
         const routes = {};
         for (const [route, pools] of Object.entries(this.routing)) {
@@ -717,7 +730,10 @@ export class VirtualRouterEngine {
             isProviderCoolingDown: (key) => this.isProviderCoolingDown(key),
             resolveStickyKey: (m) => this.resolveStickyKey(m),
             quotaView: this.quotaView,
-            aliasQueueStore: this.aliasQueueStore
+            aliasQueueStore: this.aliasQueueStore,
+            antigravityAliasLeaseStore: this.antigravityAliasLeaseStore,
+            antigravitySessionAliasStore: this.antigravitySessionAliasStore,
+            antigravityAliasReuseCooldownMs: this.antigravityAliasReuseCooldownMs
         }, { routingState });
     }
     incrementRouteStat(routeName, providerKey) {
@@ -764,6 +780,262 @@ export class VirtualRouterEngine {
         }
         return undefined;
     }
+    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;
+    }
+    resolveAntigravityLeaseScope(providerKey) {
+        try {
+            const profile = this.providerRegistry.get(providerKey);
+            const modelId = typeof profile?.modelId === 'string' ? profile.modelId.trim().toLowerCase() : '';
+            if (modelId.startsWith('gemini-')) {
+                return 'gemini';
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    buildScopedSessionKey(sessionKey) {
+        return `${sessionKey}::gemini`;
+    }
+    buildAntigravityLeaseRuntimeKey(runtimeKey) {
+        return `${runtimeKey}::gemini`;
+    }
+    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}`;
+    }
+    recordAntigravitySessionLease(metadata, providerKey, opts) {
+        // Per-request runtime override: allow callers (e.g. servertool followups) to disable
+        // Antigravity gemini session binding/lease without changing global config.
+        try {
+            const rt = 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 = this.resolveSessionScope(metadata);
+        if (!sessionKey) {
+            return;
+        }
+        const runtimeKeyBase = this.extractRuntimeKey(providerKey);
+        if (!runtimeKeyBase || !runtimeKeyBase.startsWith('antigravity.')) {
+            return;
+        }
+        const commitSessionBinding = opts?.commitSessionBinding === true;
+        const scope = this.resolveAntigravityLeaseScope(providerKey);
+        // Policy: antigravity alias leasing/binding applies only to Gemini models.
+        if (scope !== 'gemini') {
+            return;
+        }
+        const scopedSessionKey = this.buildScopedSessionKey(sessionKey);
+        const runtimeKey = this.buildAntigravityLeaseRuntimeKey(runtimeKeyBase);
+        const now = Date.now();
+        const cooldownMs = this.antigravityAliasReuseCooldownMs;
+        const existing = this.antigravityAliasLeaseStore.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;
+        }
+        this.antigravityAliasLeaseStore.set(runtimeKey, { sessionKey: scopedSessionKey, lastSeenAt: now });
+        if (commitSessionBinding) {
+            const previous = this.antigravitySessionAliasStore.get(scopedSessionKey);
+            this.antigravitySessionAliasStore.set(scopedSessionKey, runtimeKey);
+            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 && previous !== runtimeKey) {
+                    this.debug?.log?.('[virtual-router][antigravity-session-binding] commit', JSON.stringify({ sessionKey: scopedSessionKey, runtimeKey, prev: previous ?? null }));
+                }
+            }
+            catch {
+                // ignore logging errors
+            }
+        }
+        this.scheduleAntigravityAliasLeaseStoreFlush();
+        // Opportunistic cleanup: keep only active leases within cooldown window.
+        if (cooldownMs <= 0) {
+            return;
+        }
+        for (const [key, entry] of this.antigravityAliasLeaseStore.entries()) {
+            if (now - entry.lastSeenAt >= cooldownMs) {
+                this.antigravityAliasLeaseStore.delete(key);
+                // Clear session mapping if it still points at the expired runtimeKey.
+                if (this.antigravitySessionAliasStore.get(entry.sessionKey) === key) {
+                    this.antigravitySessionAliasStore.delete(entry.sessionKey);
+                }
+            }
+        }
+    }
+    resolveAntigravityAliasLeasePersistPath() {
+        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;
+            }
+            const home = os.homedir();
+            if (!home)
+                return null;
+            return path.join(home, '.routecodex', 'state', 'antigravity-alias-leases.json');
+        }
+        catch {
+            return null;
+        }
+    }
+    hydrateAntigravityAliasLeaseStoreIfNeeded(force = false) {
+        const filePath = this.resolveAntigravityAliasLeasePersistPath();
+        if (!filePath) {
+            return;
+        }
+        let stat = null;
+        try {
+            stat = fs.statSync(filePath);
+        }
+        catch {
+            this.antigravityLeasePersistence.loadedOnce = true;
+            this.antigravityLeasePersistence.loadedMtimeMs = null;
+            return;
+        }
+        const mtimeMs = typeof stat.mtimeMs === 'number' && Number.isFinite(stat.mtimeMs) ? stat.mtimeMs : stat.mtime.getTime();
+        if (!force && this.antigravityLeasePersistence.loadedOnce && this.antigravityLeasePersistence.loadedMtimeMs === mtimeMs) {
+            return;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        }
+        catch {
+            this.antigravityLeasePersistence.loadedOnce = true;
+            this.antigravityLeasePersistence.loadedMtimeMs = mtimeMs;
+            return;
+        }
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            this.antigravityLeasePersistence.loadedOnce = true;
+            this.antigravityLeasePersistence.loadedMtimeMs = mtimeMs;
+            return;
+        }
+        const leasesRaw = parsed.leases;
+        if (!leasesRaw || typeof leasesRaw !== 'object' || Array.isArray(leasesRaw)) {
+            this.antigravityLeasePersistence.loadedOnce = true;
+            this.antigravityLeasePersistence.loadedMtimeMs = mtimeMs;
+            return;
+        }
+        const now = Date.now();
+        const cooldownMs = this.antigravityAliasReuseCooldownMs;
+        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 : this.buildAntigravityLeaseRuntimeKey(runtimeKeyBase);
+            if (rawSessionKey.includes('::') && !rawSessionKey.endsWith('::gemini'))
+                continue;
+            const sessionKey = rawSessionKey.includes('::') ? rawSessionKey : this.buildScopedSessionKey(rawSessionKey);
+            nextLeaseStore.set(runtimeKey, { sessionKey, lastSeenAt });
+        }
+        this.antigravityAliasLeaseStore.clear();
+        for (const [key, val] of nextLeaseStore.entries()) {
+            this.antigravityAliasLeaseStore.set(key, val);
+        }
+        this.antigravityLeasePersistence.loadedOnce = true;
+        this.antigravityLeasePersistence.loadedMtimeMs = mtimeMs;
+    }
+    scheduleAntigravityAliasLeaseStoreFlush() {
+        if (this.antigravityLeasePersistence.flushTimer) {
+            return;
+        }
+        this.antigravityLeasePersistence.flushTimer = setTimeout(() => {
+            this.antigravityLeasePersistence.flushTimer = null;
+            this.flushAntigravityAliasLeaseStoreSync();
+        }, 250);
+        this.antigravityLeasePersistence.flushTimer.unref?.();
+    }
+    flushAntigravityAliasLeaseStoreSync() {
+        const filePath = this.resolveAntigravityAliasLeasePersistPath();
+        if (!filePath) {
+            return;
+        }
+        try {
+            fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        }
+        catch {
+            // ignore
+        }
+        const now = Date.now();
+        const cooldownMs = this.antigravityAliasReuseCooldownMs;
+        const leases = {};
+        for (const [runtimeKey, entry] of this.antigravityAliasLeaseStore.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();
+                this.antigravityLeasePersistence.loadedOnce = true;
+                this.antigravityLeasePersistence.loadedMtimeMs = mtimeMs;
+            }
+            catch {
+                // ignore
+            }
+        }
+        catch {
+            // best-effort persistence: must not affect routing
+        }
+    }
     resolveStopMessageScope(metadata) {
         const sessionId = typeof metadata.sessionId === 'string' ? metadata.sessionId.trim() : '';
         if (sessionId) {
@@ -1133,7 +1405,8 @@ export class VirtualRouterEngine {
         ]));
         const disabledModels = new Map(Array.from(state.disabledModels.entries()).map(([provider, models]) => [provider, new Set(models)]));
         // 初始候选集合：sticky 池中的所有 key
-        let candidates = Array.from(stickyKeySet).filter((key) => !this.isProviderCoolingDown(key));
+        // In quota routing mode, cooldown is controlled by quotaView only.
+        let candidates = Array.from(stickyKeySet).filter((key) => (this.quotaView ? true : !this.isProviderCoolingDown(key)));
         // 应用 provider 白名单 / 黑名单
         if (allowedProviders.size > 0) {
             candidates = candidates.filter((key) => {
@@ -1474,6 +1747,11 @@ export class VirtualRouterEngine {
         if (!this.healthStore || typeof this.healthStore.loadInitialSnapshot !== 'function') {
             return;
         }
+        // When quotaView is enabled, health/cooldown must be driven by quotaView only.
+        // Do not restore legacy router-local cooldown TTLs from health snapshots.
+        if (this.quotaView) {
+            return;
+        }
         let snapshot = null;
         try {
             snapshot = this.healthStore.loadInitialSnapshot();

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

@@ -1,8 +1,23 @@
 import { detectExtendedThinkingKeyword, detectImageAttachment, detectKeyword, extractMessageText, getLatestMessageRole, getLatestUserMessage } from './message-utils.js';
+import { extractAntigravityGeminiSessionId } from '../../conversion/compat/antigravity-session-signature.js';
 import { detectCodingTool, detectLastAssistantToolCategory, detectVisionTool, detectWebTool, extractMeaningfulDeclaredToolNames } from './tool-signals.js';
 import { computeRequestTokens } from './token-estimator.js';
 const THINKING_KEYWORDS = ['let me think', 'chain of thought', 'cot', 'reason step', 'deliberate'];
 export function buildRoutingFeatures(request, metadata) {
+    const antigravitySessionId = (() => {
+        try {
+            const messages = Array.isArray(request.messages) ? request.messages : [];
+            const contents = messages.map((msg) => {
+                const role = msg?.role === 'user' ? 'user' : 'assistant';
+                const text = msg ? extractMessageText(msg) : '';
+                return { role, parts: [{ text }] };
+            });
+            return extractAntigravityGeminiSessionId({ contents });
+        }
+        catch {
+            return undefined;
+        }
+    })();
     const latestUserMessage = getLatestUserMessage(request.messages);
     const latestMessageRole = getLatestMessageRole(request.messages);
     const assistantMessages = request.messages.filter((msg) => msg.role === 'assistant');
@@ -14,7 +29,9 @@ export function buildRoutingFeatures(request, metadata) {
     const estimatedTokens = computeRequestTokens(request, latestUserText);
     const hasThinking = detectKeyword(normalizedUserText, THINKING_KEYWORDS);
     const hasVisionTool = detectVisionTool(request);
-    const hasImageAttachment = detectImageAttachment(latestUserMessage);
+    // Vision routing must only trigger for the current user turn (latest message),
+    // not for historical user messages carrying images during tool/assistant followups.
+    const hasImageAttachment = latestMessageRole === 'user' && detectImageAttachment(latestUserMessage);
     const hasCodingTool = detectCodingTool(request);
     const hasWebTool = detectWebTool(request);
     const hasThinkingKeyword = hasThinking || detectExtendedThinkingKeyword(normalizedUserText);
@@ -50,7 +67,8 @@ export function buildRoutingFeatures(request, metadata) {
         lastAssistantToolLabel,
         latestMessageFromUser: latestMessageRole === 'user',
         metadata: {
-            ...metadata
+            ...metadata,
+            ...(antigravitySessionId ? { antigravitySessionId } : {})
         }
     };
 }

package/dist/router/virtual-router/success-center.d.ts

@@ -0,0 +1,10 @@
+import type { ProviderSuccessEvent } from './types.js';
+type ProviderSuccessListener = (event: ProviderSuccessEvent) => void;
+export declare class ProviderSuccessCenter {
+    private readonly listeners;
+    subscribe(listener: ProviderSuccessListener): () => void;
+    emit(event: ProviderSuccessEvent): ProviderSuccessEvent;
+    private normalize;
+}
+export declare const providerSuccessCenter: ProviderSuccessCenter;
+export {};

package/dist/router/virtual-router/success-center.js

@@ -0,0 +1,32 @@
+export class ProviderSuccessCenter {
+    listeners = new Set();
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    emit(event) {
+        const enriched = this.normalize(event);
+        for (const listener of this.listeners) {
+            try {
+                listener(enriched);
+            }
+            catch {
+                // Listener failures should not break propagation
+            }
+        }
+        return enriched;
+    }
+    normalize(event) {
+        const timestamp = typeof event.timestamp === 'number' ? event.timestamp : Date.now();
+        const runtime = event.runtime || {};
+        return {
+            runtime,
+            timestamp,
+            metadata: event.metadata,
+            details: event.details
+        };
+    }
+}
+export const providerSuccessCenter = new ProviderSuccessCenter();

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

@@ -166,6 +166,19 @@ export interface AliasSelectionConfig {
      * Per-provider overrides keyed by providerId (e.g. "antigravity").
      */
     providers?: Record<string, AliasSelectionStrategy>;
+    /**
+     * Antigravity session isolation cooldown window (ms).
+     * Within this window, the same Antigravity auth alias must not be reused by a different session.
+     * Default: 300000 (5 minutes).
+     */
+    sessionLeaseCooldownMs?: number;
+    /**
+     * Antigravity multi-alias session binding policy.
+     * - "lease" (default): prefer the session's last used alias, but can rotate to another alias when needed.
+     * - "strict": once a session binds to an alias, it will not switch to another alias; on failure it must
+     *   fall back to other providers/routes rather than trying a different Antigravity alias.
+     */
+    antigravitySessionBinding?: 'lease' | 'strict';
 }
 export interface ContextWeightedLoadBalancingConfig {
     /**
@@ -238,6 +251,16 @@ export interface VirtualRouterClockConfig {
      * Daemon tick interval (ms). 0 disables background cleanup tick (still cleans on load).
      */
     tickMs?: number;
+    /**
+     * Allow clock hold flow for non-streaming (JSON) requests.
+     * Default: true.
+     */
+    holdNonStreaming?: boolean;
+    /**
+     * Maximum time (ms) a request is allowed to hold waiting for due window.
+     * Default: 60s.
+     */
+    holdMaxMs?: number;
 }
 export interface VirtualRouterConfig {
     routing: RoutingPools;
@@ -284,6 +307,11 @@ export interface RouterMetadataInput {
     providerProtocol?: string;
     stage?: 'inbound' | 'outbound' | 'response';
     routeHint?: string;
+    /**
+     * Antigravity-Manager alignment: stable sessionId derived from the first user message text.
+     * Used for Antigravity alias/session binding and thoughtSignature persistence.
+     */
+    antigravitySessionId?: string;
     /**
      * Indicates that current routing decision is for a request which
      * expects server-side tools orchestration (e.g. web_search).
@@ -481,6 +509,26 @@ export interface ProviderErrorEvent {
     timestamp: number;
     details?: Record<string, unknown>;
 }
+export interface ProviderSuccessRuntimeMetadata {
+    requestId: string;
+    routeName?: string;
+    providerKey?: string;
+    providerId?: string;
+    providerType?: string;
+    providerProtocol?: string;
+    pipelineId?: string;
+    target?: TargetMetadata | Record<string, unknown>;
+}
+export interface ProviderSuccessEvent {
+    runtime: ProviderSuccessRuntimeMetadata;
+    timestamp: number;
+    /**
+     * Optional request metadata snapshot (e.g. sessionId / conversationId).
+     * This must not contain provider-specific payload semantics.
+     */
+    metadata?: Record<string, unknown>;
+    details?: Record<string, unknown>;
+}
 export interface FeatureBuilder {
     build(request: StandardizedRequest, metadata: RouterMetadataInput): RoutingFeatures;
 }

package/dist/servertool/clock/config.d.ts

@@ -3,6 +3,8 @@ export declare const CLOCK_CONFIG_DEFAULTS: {
     readonly retentionMs: number;
     readonly dueWindowMs: 60000;
     readonly tickMs: 60000;
+    readonly holdNonStreaming: true;
+    readonly holdMaxMs: 60000;
 };
 export declare function normalizeClockConfig(raw: unknown): ClockConfigSnapshot | null;
 /**

package/dist/servertool/clock/config.js

@@ -1,7 +1,9 @@
 export const CLOCK_CONFIG_DEFAULTS = {
     retentionMs: 20 * 60_000,
     dueWindowMs: 60_000,
-    tickMs: 60_000
+    tickMs: 60_000,
+    holdNonStreaming: true,
+    holdMaxMs: 60_000
 };
 export function normalizeClockConfig(raw) {
     if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
@@ -23,7 +25,13 @@ export function normalizeClockConfig(raw) {
     const tickMs = typeof record.tickMs === 'number' && Number.isFinite(record.tickMs) && record.tickMs >= 0
         ? Math.floor(record.tickMs)
         : CLOCK_CONFIG_DEFAULTS.tickMs;
-    return { enabled: true, retentionMs, dueWindowMs, tickMs };
+    const holdNonStreaming = record.holdNonStreaming === true ||
+        (typeof record.holdNonStreaming === 'string' && record.holdNonStreaming.trim().toLowerCase() === 'true') ||
+        (typeof record.holdNonStreaming === 'number' && record.holdNonStreaming === 1);
+    const holdMaxMs = typeof record.holdMaxMs === 'number' && Number.isFinite(record.holdMaxMs) && record.holdMaxMs >= 0
+        ? Math.floor(record.holdMaxMs)
+        : CLOCK_CONFIG_DEFAULTS.holdMaxMs;
+    return { enabled: true, retentionMs, dueWindowMs, tickMs, holdNonStreaming, holdMaxMs };
 }
 /**
  * Resolve the effective clock config for a request/session.

package/dist/servertool/clock/daemon.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { readSessionDirEnv, resolveClockDir } from './paths.js';
 import { cleanExpiredTasks, coerceState, nowMs } from './state.js';
 import { readJsonFile, writeJsonFileAtomic } from './io.js';
+import { startClockNtpSyncIfNeeded } from './ntp.js';
 let daemonStarted = false;
 let daemonTimer;
 let daemonConfig;
@@ -16,6 +17,8 @@ export async function startClockDaemonIfNeeded(config) {
     }
     daemonStarted = true;
     daemonConfig = config;
+    // Best-effort NTP sync (do not block daemon startup).
+    void startClockNtpSyncIfNeeded(config);
     const tickOnce = async () => {
         const effective = daemonConfig;
         if (!effective)