@jsonstudio/rcc 0.90.872 → 0.90.1270

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/engine/sticky-session-manager.js

@@ -3,36 +3,88 @@
  *
  * Sticky session and alias lease management extracted from VirtualRouterEngine.
  */
+const DEFAULT_STICKY_SESSION_TTL_MS = 30 * 60_000;
+const DEFAULT_STICKY_SESSION_MAX_ENTRIES = 4096;
+function resolveStickySessionTtlMs() {
+    const raw = process.env.ROUTECODEX_VR_STICKY_SESSION_TTL_MS ?? process.env.RCC_VR_STICKY_SESSION_TTL_MS;
+    const parsed = Number.parseInt(String(raw ?? '').trim(), 10);
+    if (Number.isFinite(parsed) && parsed >= 60_000) {
+        return parsed;
+    }
+    return DEFAULT_STICKY_SESSION_TTL_MS;
+}
+function resolveStickySessionMaxEntries() {
+    const raw = process.env.ROUTECODEX_VR_STICKY_SESSION_MAX_ENTRIES
+        ?? process.env.RCC_VR_STICKY_SESSION_MAX_ENTRIES;
+    const parsed = Number.parseInt(String(raw ?? '').trim(), 10);
+    if (Number.isFinite(parsed) && parsed >= 16) {
+        return parsed;
+    }
+    return DEFAULT_STICKY_SESSION_MAX_ENTRIES;
+}
 export class StickySessionManager {
     aliasQueueStore = new Map();
     antigravityAliasLeaseStore = new Map();
     antigravitySessionAliasStore = new Map();
+    aliasQueueTouchedAt = new Map();
+    sessionAliasTouchedAt = new Map();
     antigravityAliasReuseCooldownMs = 5 * 60_000;
+    stickySessionTtlMs;
+    stickySessionMaxEntries;
     constructor(aliasReuseCooldownMs) {
         if (typeof aliasReuseCooldownMs === 'number' && aliasReuseCooldownMs > 0) {
             this.antigravityAliasReuseCooldownMs = aliasReuseCooldownMs;
         }
+        this.stickySessionTtlMs = resolveStickySessionTtlMs();
+        this.stickySessionMaxEntries = resolveStickySessionMaxEntries();
     }
     // Alias queue management
     getAliasQueue(alias) {
-        return this.aliasQueueStore.get(alias);
+        this.prune(Date.now());
+        const queue = this.aliasQueueStore.get(alias);
+        if (queue) {
+            this.aliasQueueTouchedAt.set(alias, Date.now());
+        }
+        return queue;
     }
     setAliasQueue(alias, queue) {
+        const nowMs = Date.now();
+        this.prune(nowMs);
         this.aliasQueueStore.set(alias, queue);
+        this.aliasQueueTouchedAt.set(alias, nowMs);
+        this.enforceAliasQueueBudget();
     }
     // Antigravity alias lease
     getAliasLease(alias) {
+        this.prune(Date.now());
         return this.antigravityAliasLeaseStore.get(alias);
     }
     setAliasLease(alias, lease) {
-        this.antigravityAliasLeaseStore.set(alias, lease);
+        const nowMs = Date.now();
+        this.prune(nowMs);
+        this.antigravityAliasLeaseStore.set(alias, {
+            ...lease,
+            lastSeenAt: typeof lease?.lastSeenAt === 'number' && Number.isFinite(lease.lastSeenAt) && lease.lastSeenAt > 0
+                ? lease.lastSeenAt
+                : nowMs
+        });
+        this.enforceAliasLeaseBudget();
     }
     // Session alias mapping
     getSessionAlias(sessionKey) {
-        return this.antigravitySessionAliasStore.get(sessionKey);
+        this.prune(Date.now());
+        const alias = this.antigravitySessionAliasStore.get(sessionKey);
+        if (alias) {
+            this.sessionAliasTouchedAt.set(sessionKey, Date.now());
+        }
+        return alias;
     }
     setSessionAlias(sessionKey, alias) {
+        const nowMs = Date.now();
+        this.prune(nowMs);
         this.antigravitySessionAliasStore.set(sessionKey, alias);
+        this.sessionAliasTouchedAt.set(sessionKey, nowMs);
+        this.enforceSessionAliasBudget();
     }
     // Cooldown resolution
     getAliasReuseCooldownMs() {
@@ -40,16 +92,99 @@ export class StickySessionManager {
     }
     // Hydrate from external store (placeholder for future persistence)
     hydrateFromStore(store) {
+        const nowMs = Date.now();
+        this.prune(nowMs);
         for (const [alias, lease] of store.entries()) {
-            this.antigravityAliasLeaseStore.set(alias, lease);
+            this.antigravityAliasLeaseStore.set(alias, {
+                ...lease,
+                lastSeenAt: typeof lease?.lastSeenAt === 'number' && Number.isFinite(lease.lastSeenAt) && lease.lastSeenAt > 0
+                    ? lease.lastSeenAt
+                    : nowMs
+            });
         }
+        this.enforceAliasLeaseBudget();
     }
     // Get all stores for persistence
     getAllStores() {
+        this.prune(Date.now());
         return {
             aliasQueueStore: this.aliasQueueStore,
             aliasLeaseStore: this.antigravityAliasLeaseStore,
             sessionAliasStore: this.antigravitySessionAliasStore
         };
     }
+    prune(nowMs) {
+        for (const [alias, touchedAtMs] of this.aliasQueueTouchedAt.entries()) {
+            if (nowMs - touchedAtMs >= this.stickySessionTtlMs) {
+                this.aliasQueueTouchedAt.delete(alias);
+                this.aliasQueueStore.delete(alias);
+            }
+        }
+        const expiredAliases = new Set();
+        for (const [alias, lease] of this.antigravityAliasLeaseStore.entries()) {
+            const lastSeenAt = typeof lease?.lastSeenAt === 'number' && Number.isFinite(lease.lastSeenAt)
+                ? lease.lastSeenAt
+                : 0;
+            if (nowMs - lastSeenAt >= this.stickySessionTtlMs) {
+                expiredAliases.add(alias);
+                this.antigravityAliasLeaseStore.delete(alias);
+            }
+        }
+        if (expiredAliases.size > 0) {
+            for (const [sessionKey, alias] of this.antigravitySessionAliasStore.entries()) {
+                if (!expiredAliases.has(alias)) {
+                    continue;
+                }
+                this.antigravitySessionAliasStore.delete(sessionKey);
+                this.sessionAliasTouchedAt.delete(sessionKey);
+            }
+        }
+        for (const [sessionKey, touchedAtMs] of this.sessionAliasTouchedAt.entries()) {
+            if (nowMs - touchedAtMs >= this.stickySessionTtlMs) {
+                this.sessionAliasTouchedAt.delete(sessionKey);
+                this.antigravitySessionAliasStore.delete(sessionKey);
+            }
+        }
+        this.enforceAliasQueueBudget();
+        this.enforceAliasLeaseBudget();
+        this.enforceSessionAliasBudget();
+    }
+    enforceAliasQueueBudget() {
+        this.evictTouchedMapBudget(this.aliasQueueTouchedAt, (key) => {
+            this.aliasQueueStore.delete(key);
+        });
+    }
+    enforceAliasLeaseBudget() {
+        if (this.antigravityAliasLeaseStore.size <= this.stickySessionMaxEntries) {
+            return;
+        }
+        const sorted = Array.from(this.antigravityAliasLeaseStore.entries()).sort((a, b) => a[1].lastSeenAt - b[1].lastSeenAt);
+        while (this.antigravityAliasLeaseStore.size > this.stickySessionMaxEntries && sorted.length > 0) {
+            const [alias] = sorted.shift();
+            this.antigravityAliasLeaseStore.delete(alias);
+            for (const [sessionKey, mappedAlias] of this.antigravitySessionAliasStore.entries()) {
+                if (mappedAlias !== alias) {
+                    continue;
+                }
+                this.antigravitySessionAliasStore.delete(sessionKey);
+                this.sessionAliasTouchedAt.delete(sessionKey);
+            }
+        }
+    }
+    enforceSessionAliasBudget() {
+        this.evictTouchedMapBudget(this.sessionAliasTouchedAt, (key) => {
+            this.antigravitySessionAliasStore.delete(key);
+        });
+    }
+    evictTouchedMapBudget(touchedAtMap, onDelete) {
+        if (touchedAtMap.size <= this.stickySessionMaxEntries) {
+            return;
+        }
+        const sorted = Array.from(touchedAtMap.entries()).sort((a, b) => a[1] - b[1]);
+        while (touchedAtMap.size > this.stickySessionMaxEntries && sorted.length > 0) {
+            const [key] = sorted.shift();
+            touchedAtMap.delete(key);
+            onDelete(key);
+        }
+    }
 }

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/engine-logging.js

@@ -197,7 +197,8 @@ export function resolveSessionColor(sessionId) {
     hash ^= hash >>> 15;
     hash = Math.imul(hash, 0x846ca68b) >>> 0;
     hash ^= hash >>> 16;
-    return palette[hash % palette.length];
+    const normalizedHash = hash >>> 0;
+    return palette[normalizedHash % palette.length];
 }
 function describeContextUsage(providerKey, estimatedTokens, deps) {
     if (typeof estimatedTokens !== 'number' || !Number.isFinite(estimatedTokens) || estimatedTokens <= 0) {

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/engine-selection/native-chat-process-clock-reminder-semantics.js

@@ -1,99 +1,108 @@
 import { failNativeRequired, isNativeDisabledByEnv } from './native-router-hotpath-policy.js';
 import { loadNativeRouterHotpathBindingForInternalUse } from './native-router-hotpath.js';
+const NON_BLOCKING_CLOCK_REMINDER_LOG_THROTTLE_MS = 60_000;
+const nonBlockingClockReminderLogState = new Map();
+const JSON_PARSE_FAILED = Symbol('native-chat-process-clock-reminder-semantics.parse-failed');
+function formatUnknownError(error) {
+    if (error instanceof Error) {
+        return error.stack || `${error.name}: ${error.message}`;
+    }
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error ?? 'unknown');
+    }
+}
+function logNativeClockReminderNonBlocking(stage, error) {
+    const now = Date.now();
+    const last = nonBlockingClockReminderLogState.get(stage) ?? 0;
+    if (now - last < NON_BLOCKING_CLOCK_REMINDER_LOG_THROTTLE_MS) {
+        return;
+    }
+    nonBlockingClockReminderLogState.set(stage, now);
+    console.warn(`[native-chat-process-clock-reminder-semantics] ${stage} failed (non-blocking): ${formatUnknownError(error)}`);
+}
+function parseJson(stage, raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        logNativeClockReminderNonBlocking(stage, error);
+        return JSON_PARSE_FAILED;
+    }
+}
 function readNativeFunction(name) {
     const binding = loadNativeRouterHotpathBindingForInternalUse();
     const fn = binding?.[name];
     return typeof fn === 'function' ? fn : null;
 }
 function parseArray(raw) {
-    try {
-        const parsed = JSON.parse(raw);
-        return Array.isArray(parsed) ? parsed : null;
-    }
-    catch {
+    const parsed = parseJson('parseArray', raw);
+    if (parsed === JSON_PARSE_FAILED) {
         return null;
     }
+    return Array.isArray(parsed) ? parsed : null;
 }
 function parseRecordOrNull(raw) {
-    try {
-        const parsed = JSON.parse(raw);
-        if (parsed === null) {
-            return null;
-        }
-        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-            return null;
-        }
-        return parsed;
+    const parsed = parseJson('parseRecordOrNull', raw);
+    if (parsed === JSON_PARSE_FAILED || parsed === null) {
+        return null;
     }
-    catch {
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
         return null;
     }
+    return parsed;
 }
 function parseRecordOrNullResult(raw) {
-    try {
-        const parsed = JSON.parse(raw);
-        if (parsed === null) {
-            return { ok: true, value: null };
-        }
-        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-            return { ok: false };
-        }
-        return { ok: true, value: parsed };
+    const parsed = parseJson('parseRecordOrNullResult', raw);
+    if (parsed === JSON_PARSE_FAILED) {
+        return { ok: false };
     }
-    catch {
+    if (parsed === null) {
+        return { ok: true, value: null };
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
         return { ok: false };
     }
+    return { ok: true, value: parsed };
 }
 function parseRecord(raw) {
-    try {
-        const parsed = JSON.parse(raw);
-        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-            return null;
-        }
-        return parsed;
-    }
-    catch {
+    const parsed = parseJson('parseRecord', raw);
+    if (parsed === JSON_PARSE_FAILED || !parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
         return null;
     }
+    return parsed;
 }
 function parseIndex(raw) {
-    try {
-        const parsed = JSON.parse(raw);
-        if (typeof parsed !== 'number' || !Number.isFinite(parsed)) {
-            return null;
-        }
-        return Math.floor(parsed);
-    }
-    catch {
+    const parsed = parseJson('parseIndex', raw);
+    if (parsed === JSON_PARSE_FAILED || typeof parsed !== 'number' || !Number.isFinite(parsed)) {
         return null;
     }
+    return Math.floor(parsed);
 }
 function parseStringOrNull(raw) {
-    try {
-        const parsed = JSON.parse(raw);
-        if (parsed === null) {
-            return null;
-        }
-        return typeof parsed === 'string' ? parsed : undefined;
-    }
-    catch {
+    const parsed = parseJson('parseStringOrNull', raw);
+    if (parsed === JSON_PARSE_FAILED) {
         return undefined;
     }
+    if (parsed === null) {
+        return null;
+    }
+    return typeof parsed === 'string' ? parsed : undefined;
 }
 function parseClockConfigOrNull(raw) {
-    try {
-        const parsed = JSON.parse(raw);
-        if (parsed === null) {
-            return null;
-        }
-        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-            return undefined;
-        }
-        return parsed;
+    const parsed = parseJson('parseClockConfigOrNull', raw);
+    if (parsed === JSON_PARSE_FAILED) {
+        return undefined;
     }
-    catch {
+    if (parsed === null) {
+        return null;
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
         return undefined;
     }
+    return parsed;
 }
 export function resolveClockConfigWithNative(raw, rawIsUndefined) {
     const capability = 'resolveClockConfigJson';