@jsonstudio/llms 0.6.954 → 0.6.1172

package/dist/router/virtual-router/sticky-session-store.js

@@ -2,6 +2,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import os from 'node:os';
 import { serializeRoutingInstructionState, deserializeRoutingInstructionState } from './routing-instructions.js';
+const pendingWrites = new Map();
 function isPersistentKey(key) {
     if (!key)
         return false;
@@ -54,7 +55,26 @@ export function loadRoutingInstructionStateSync(key) {
         if (!raw) {
             return null;
         }
-        const parsed = JSON.parse(raw);
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            const recovered = recoverPersistedJson(raw);
+            if (!recovered) {
+                return null;
+            }
+            parsed = recovered;
+            try {
+                const payload = parsed && typeof parsed.version === 'number'
+                    ? parsed
+                    : { version: 1, state: parsed };
+                atomicWriteFileSync(filepath, JSON.stringify(payload));
+            }
+            catch {
+                // ignore rewrite failures
+            }
+        }
         const payload = parsed && typeof parsed.version === 'number'
             ? parsed.state
             : parsed;
@@ -79,34 +99,34 @@ export function saveRoutingInstructionStateAsync(key, state) {
     const filepath = path.join(dir, filename);
     // 空状态意味着清除持久化文件
     if (!state) {
-        try {
-            fs.unlink(filepath, () => {
-                // ignore errors (e.g. ENOENT)
-            });
-        }
-        catch {
-            // ignore sync unlink failures
-        }
+        scheduleWrite(filepath, async () => {
+            try {
+                await fs.promises.unlink(filepath);
+            }
+            catch {
+                // ignore unlink errors (e.g. ENOENT)
+            }
+        });
         return;
     }
     const payload = {
         version: 1,
         state: serializeRoutingInstructionState(state)
     };
-    try {
-        fs.mkdirSync(dir, { recursive: true });
-    }
-    catch {
-        // ignore mkdir errors; write below will fail silently
-    }
-    try {
-        fs.writeFile(filepath, JSON.stringify(payload), { encoding: 'utf8' }, () => {
-            // ignore async write errors
-        });
-    }
-    catch {
-        // ignore sync write failures
-    }
+    scheduleWrite(filepath, async () => {
+        try {
+            await fs.promises.mkdir(dir, { recursive: true });
+        }
+        catch {
+            // ignore mkdir errors; write below will fail silently
+        }
+        try {
+            await atomicWriteFile(filepath, JSON.stringify(payload));
+        }
+        catch {
+            // ignore async write failures
+        }
+    });
 }
 export function saveRoutingInstructionStateSync(key, state) {
     if (!isPersistentKey(key)) {
@@ -138,9 +158,101 @@ export function saveRoutingInstructionStateSync(key, state) {
         // ignore mkdir errors
     }
     try {
-        fs.writeFileSync(filepath, JSON.stringify(payload), { encoding: 'utf8' });
+        atomicWriteFileSync(filepath, JSON.stringify(payload));
     }
     catch {
         // ignore sync write failures
     }
 }
+function scheduleWrite(filepath, task) {
+    const previous = pendingWrites.get(filepath) ?? Promise.resolve();
+    const next = previous
+        .then(task)
+        .catch(() => {
+        // swallow errors
+    })
+        .finally(() => {
+        if (pendingWrites.get(filepath) === next) {
+            pendingWrites.delete(filepath);
+        }
+    });
+    pendingWrites.set(filepath, next);
+}
+async function atomicWriteFile(filepath, content) {
+    const tmp = `${filepath}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    try {
+        await fs.promises.writeFile(tmp, content, { encoding: 'utf8' });
+        try {
+            await fs.promises.rename(tmp, filepath);
+        }
+        catch {
+            try {
+                await fs.promises.unlink(filepath);
+            }
+            catch {
+                // ignore unlink failures
+            }
+            await fs.promises.rename(tmp, filepath);
+        }
+    }
+    finally {
+        try {
+            await fs.promises.unlink(tmp);
+        }
+        catch {
+            // ignore tmp cleanup failures
+        }
+    }
+}
+function atomicWriteFileSync(filepath, content) {
+    const tmp = `${filepath}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    try {
+        fs.writeFileSync(tmp, content, { encoding: 'utf8' });
+        try {
+            fs.renameSync(tmp, filepath);
+        }
+        catch {
+            try {
+                fs.unlinkSync(filepath);
+            }
+            catch {
+                // ignore unlink failures
+            }
+            fs.renameSync(tmp, filepath);
+        }
+    }
+    finally {
+        try {
+            fs.unlinkSync(tmp);
+        }
+        catch {
+            // ignore tmp cleanup failures
+        }
+    }
+}
+function recoverPersistedJson(raw) {
+    if (typeof raw !== 'string') {
+        return null;
+    }
+    const text = raw.trim();
+    if (!text.startsWith('{')) {
+        return null;
+    }
+    const maxScan = Math.min(text.length, 256 * 1024);
+    for (let i = maxScan - 1; i >= 1; i -= 1) {
+        if (text[i] !== '}') {
+            continue;
+        }
+        const candidate = text.slice(0, i + 1);
+        try {
+            const parsed = JSON.parse(candidate);
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                return parsed;
+            }
+        }
+        catch {
+            // keep scanning
+        }
+    }
+    return null;
+}

package/dist/router/virtual-router/stop-message-file-resolver.d.ts

@@ -0,0 +1 @@
+export declare function resolveStopMessageText(raw: string): string;

package/dist/router/virtual-router/stop-message-file-resolver.js

@@ -0,0 +1,74 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import os from 'node:os';
+const cache = new Map();
+function resolveRoutecodexUserDir() {
+    const override = process.env.ROUTECODEX_USER_DIR;
+    if (override && override.trim()) {
+        return override.trim();
+    }
+    const home = os.homedir();
+    if (!home) {
+        throw new Error('stopMessage file://: cannot resolve homedir');
+    }
+    return path.join(home, '.routecodex');
+}
+function resolveStopMessageFilePath(raw) {
+    let text = raw.trim();
+    if (!text)
+        return null;
+    if (text.startsWith('<') && text.endsWith('>') && text.length >= 3) {
+        text = text.slice(1, -1).trim();
+    }
+    if (!/^file:\/\//i.test(text)) {
+        return null;
+    }
+    const relRaw = text.slice('file://'.length).trim();
+    if (!relRaw) {
+        throw new Error('stopMessage file://: missing relative path');
+    }
+    if (relRaw.startsWith('/') || relRaw.startsWith('\\') || /^[a-zA-Z]:[\\/]/.test(relRaw)) {
+        throw new Error('stopMessage file://: only supports paths relative to ~/.routecodex');
+    }
+    const normalizedRel = path.posix.normalize(relRaw.replace(/\\/g, '/'));
+    if (!normalizedRel || normalizedRel === '.' || normalizedRel === '..' || normalizedRel.startsWith('../')) {
+        throw new Error('stopMessage file://: invalid relative path');
+    }
+    const base = path.resolve(resolveRoutecodexUserDir());
+    const abs = path.resolve(base, normalizedRel);
+    if (abs !== base && !abs.startsWith(`${base}${path.sep}`)) {
+        throw new Error('stopMessage file://: path escapes ~/.routecodex');
+    }
+    return abs;
+}
+export function resolveStopMessageText(raw) {
+    const abs = resolveStopMessageFilePath(raw);
+    if (!abs) {
+        return raw;
+    }
+    let stat;
+    try {
+        stat = fs.statSync(abs);
+    }
+    catch (err) {
+        const message = err && typeof err.message === 'string' ? err.message : String(err || 'unknown error');
+        throw new Error(`stopMessage file://: cannot stat ${abs}: ${message}`);
+    }
+    if (!stat.isFile()) {
+        throw new Error(`stopMessage file://: not a file: ${abs}`);
+    }
+    const existing = cache.get(abs);
+    if (existing && existing.mtimeMs === stat.mtimeMs && existing.size === stat.size) {
+        return existing.content;
+    }
+    let content;
+    try {
+        content = fs.readFileSync(abs, 'utf8');
+    }
+    catch (err) {
+        const message = err && typeof err.message === 'string' ? err.message : String(err || 'unknown error');
+        throw new Error(`stopMessage file://: cannot read ${abs}: ${message}`);
+    }
+    cache.set(abs, { mtimeMs: stat.mtimeMs, size: stat.size, content });
+    return content;
+}

package/dist/router/virtual-router/stop-message-state-sync.d.ts

@@ -0,0 +1,15 @@
+import type { RoutingInstructionState } from './routing-instructions.js';
+type StopMessageSubset = Pick<RoutingInstructionState, 'stopMessageSource' | 'stopMessageText' | 'stopMessageMaxRepeats' | 'stopMessageUsed' | 'stopMessageUpdatedAt' | 'stopMessageLastUsedAt'>;
+/**
+ * Decide whether we should overwrite in-memory stopMessage fields with persisted ones.
+ *
+ * Key invariant:
+ * - In-memory state may be ahead of disk because persistence is async (tmp+rename).
+ * - Persisted state must still be able to update usage counters (stop_message_auto).
+ *
+ * Strategy:
+ * - If existing has a newer stopMessageUpdatedAt than persisted → keep existing config.
+ * - Otherwise → adopt persisted fully.
+ */
+export declare function mergeStopMessageFromPersisted(existing: StopMessageSubset, persisted: StopMessageSubset | null): StopMessageSubset;
+export {};

package/dist/router/virtual-router/stop-message-state-sync.js

@@ -0,0 +1,57 @@
+function isFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function updatedAtOf(state) {
+    if (!state)
+        return null;
+    return isFiniteNumber(state.stopMessageUpdatedAt) ? state.stopMessageUpdatedAt : null;
+}
+function lastUsedAtOf(state) {
+    if (!state)
+        return null;
+    return isFiniteNumber(state.stopMessageLastUsedAt) ? state.stopMessageLastUsedAt : null;
+}
+/**
+ * Decide whether we should overwrite in-memory stopMessage fields with persisted ones.
+ *
+ * Key invariant:
+ * - In-memory state may be ahead of disk because persistence is async (tmp+rename).
+ * - Persisted state must still be able to update usage counters (stop_message_auto).
+ *
+ * Strategy:
+ * - If existing has a newer stopMessageUpdatedAt than persisted → keep existing config.
+ * - Otherwise → adopt persisted fully.
+ */
+export function mergeStopMessageFromPersisted(existing, persisted) {
+    if (!persisted) {
+        return { ...existing };
+    }
+    const existingUpdatedAt = updatedAtOf(existing);
+    const persistedUpdatedAt = updatedAtOf(persisted);
+    const existingIsNewer = existingUpdatedAt !== null && (persistedUpdatedAt === null || persistedUpdatedAt < existingUpdatedAt);
+    if (!existingIsNewer) {
+        return {
+            ...existing,
+            stopMessageSource: persisted.stopMessageSource,
+            stopMessageText: persisted.stopMessageText,
+            stopMessageMaxRepeats: persisted.stopMessageMaxRepeats,
+            stopMessageUsed: persisted.stopMessageUsed,
+            stopMessageUpdatedAt: persisted.stopMessageUpdatedAt,
+            stopMessageLastUsedAt: persisted.stopMessageLastUsedAt
+        };
+    }
+    // Keep existing config, but still allow persisted usage counters to move forward if they are newer.
+    const existingLastUsedAt = lastUsedAtOf(existing);
+    const persistedLastUsedAt = lastUsedAtOf(persisted);
+    const countersAreNewer = persistedLastUsedAt !== null &&
+        (existingLastUsedAt === null || persistedLastUsedAt > existingLastUsedAt);
+    return {
+        ...existing,
+        ...(countersAreNewer
+            ? {
+                stopMessageUsed: persisted.stopMessageUsed,
+                stopMessageLastUsedAt: persisted.stopMessageLastUsedAt
+            }
+            : {})
+    };
+}

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

@@ -100,6 +100,69 @@ export interface VirtualRouterClassifierConfig {
 export interface LoadBalancingPolicy {
     strategy: 'round-robin' | 'weighted' | 'sticky';
     weights?: Record<string, number>;
+    /**
+     * AWRR: health-weighted selection.
+     * - Deterministic (no randomness)
+     * - Penalizes recently failing keys but never to zero
+     * - Gradually recovers weights as time passes without errors
+     */
+    healthWeighted?: HealthWeightedLoadBalancingConfig;
+    /**
+     * Context-aware weighting (best-fit under safe window):
+     * - Prefer smaller effective context windows early, to preserve larger windows for later.
+     * - Uses ContextAdvisor's warnRatio to compute an "effective safe window" per model.
+     * - Caps comparisons by client context (e.g. 200k).
+     */
+    contextWeighted?: ContextWeightedLoadBalancingConfig;
+}
+export interface HealthWeightedLoadBalancingConfig {
+    /**
+     * When false, health-weighted logic is disabled and the engine uses legacy behavior.
+     * When true/undefined, the engine uses health-weighted behavior if quotaView provides error metadata.
+     */
+    enabled?: boolean;
+    /**
+     * Weight resolution. Higher values increase granularity but not semantics.
+     */
+    baseWeight?: number;
+    /**
+     * Lower bound for the health multiplier (0 < minMultiplier <= 1).
+     * Example: 0.5 means a key's share won't be penalized below ~50% baseline within the same pool.
+     */
+    minMultiplier?: number;
+    /**
+     * Penalty slope. Larger beta penalizes errors more aggressively.
+     */
+    beta?: number;
+    /**
+     * Half-life for time-based recovery after the last error.
+     */
+    halfLifeMs?: number;
+    /**
+     * When true, a router-level retry attempt (excludedProviderKeys non-empty) prefers the healthiest candidate first.
+     */
+    recoverToBestOnRetry?: boolean;
+}
+export interface ContextWeightedLoadBalancingConfig {
+    /**
+     * When false, context-weighted logic is disabled.
+     * When true/undefined, context-weighted logic applies within the same pool bucket,
+     * and only for candidates that are considered "safe" by ContextAdvisor.
+     */
+    enabled?: boolean;
+    /**
+     * Client-side maximum usable context (tokens). Models above this are capped.
+     * Example: 200000 for Codex/Claude Code style clients.
+     */
+    clientCapTokens?: number;
+    /**
+     * Exponent for the compensation ratio. Use 1 for proportional compensation.
+     */
+    gamma?: number;
+    /**
+     * Upper bound for the multiplier to avoid extreme skew.
+     */
+    maxMultiplier?: number;
 }
 export interface ProviderHealthConfig {
     failureThreshold: number;
@@ -136,6 +199,22 @@ export interface VirtualRouterExecCommandGuardConfig {
      */
     policyFile?: string;
 }
+export interface VirtualRouterClockConfig {
+    enabled: boolean;
+    /**
+     * Task retention after dueAt (ms). Tasks older than (dueAt + retentionMs)
+     * are eligible for cleanup.
+     */
+    retentionMs?: number;
+    /**
+     * "Due window" in ms. A task is considered due when now >= dueAt - dueWindowMs.
+     */
+    dueWindowMs?: number;
+    /**
+     * Daemon tick interval (ms). 0 disables background cleanup tick (still cleans on load).
+     */
+    tickMs?: number;
+}
 export interface VirtualRouterConfig {
     routing: RoutingPools;
     providers: Record<string, ProviderProfile>;
@@ -145,6 +224,7 @@ export interface VirtualRouterConfig {
     contextRouting?: VirtualRouterContextRoutingConfig;
     webSearch?: VirtualRouterWebSearchConfig;
     execCommandGuard?: VirtualRouterExecCommandGuardConfig;
+    clock?: VirtualRouterClockConfig;
 }
 export interface VirtualRouterContextRoutingConfig {
     warnRatio: number;
@@ -161,6 +241,7 @@ export interface VirtualRouterBootstrapInput extends Record<string, unknown> {
     contextRouting?: VirtualRouterContextRoutingConfig;
     webSearch?: VirtualRouterWebSearchConfig | Record<string, unknown>;
     execCommandGuard?: VirtualRouterExecCommandGuardConfig | Record<string, unknown>;
+    clock?: VirtualRouterClockConfig | Record<string, unknown>;
 }
 export type ProviderRuntimeMap = Record<string, ProviderRuntimeProfile>;
 export interface VirtualRouterBootstrapResult {
@@ -409,6 +490,23 @@ export interface ProviderQuotaViewEntry {
     inPool: boolean;
     reason?: string;
     priorityTier?: number;
+    /**
+     * Optional soft penalty hint for selection ordering.
+     * - 0 / undefined means no penalty
+     * - higher means less preferred (e.g. recent transient errors)
+     *
+     * This does NOT exclude the provider from the pool; exclusion is controlled by
+     * inPool/cooldownUntil/blacklistUntil.
+     */
+    selectionPenalty?: number;
+    /**
+     * Optional per-providerKey timestamp of the last error. Used for time-decayed recovery.
+     */
+    lastErrorAtMs?: number | null;
+    /**
+     * Optional per-providerKey consecutive error count. Resets to 0 on success.
+     */
+    consecutiveErrorCount?: number;
     cooldownUntil?: number | null;
     blacklistUntil?: number | null;
 }

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

@@ -0,0 +1,7 @@
+import type { ClockConfigSnapshot } from './types.js';
+export declare const CLOCK_CONFIG_DEFAULTS: {
+    readonly retentionMs: number;
+    readonly dueWindowMs: 60000;
+    readonly tickMs: 60000;
+};
+export declare function normalizeClockConfig(raw: unknown): ClockConfigSnapshot | null;

package/dist/servertool/clock/config.js

@@ -0,0 +1,27 @@
+export const CLOCK_CONFIG_DEFAULTS = {
+    retentionMs: 20 * 60_000,
+    dueWindowMs: 60_000,
+    tickMs: 60_000
+};
+export function normalizeClockConfig(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return null;
+    }
+    const record = raw;
+    const enabled = record.enabled === true ||
+        (typeof record.enabled === 'string' && record.enabled.trim().toLowerCase() === 'true') ||
+        (typeof record.enabled === 'number' && record.enabled === 1);
+    if (!enabled) {
+        return null;
+    }
+    const retentionMs = typeof record.retentionMs === 'number' && Number.isFinite(record.retentionMs) && record.retentionMs >= 0
+        ? Math.floor(record.retentionMs)
+        : CLOCK_CONFIG_DEFAULTS.retentionMs;
+    const dueWindowMs = typeof record.dueWindowMs === 'number' && Number.isFinite(record.dueWindowMs) && record.dueWindowMs >= 0
+        ? Math.floor(record.dueWindowMs)
+        : CLOCK_CONFIG_DEFAULTS.dueWindowMs;
+    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 };
+}

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

@@ -0,0 +1,3 @@
+import type { ClockConfigSnapshot } from './types.js';
+export declare function startClockDaemonIfNeeded(config: ClockConfigSnapshot): Promise<void>;
+export declare function stopClockDaemonForTests(): Promise<void>;

package/dist/servertool/clock/daemon.js

@@ -0,0 +1,79 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { readSessionDirEnv, resolveClockDir } from './paths.js';
+import { cleanExpiredTasks, coerceState, nowMs } from './state.js';
+import { readJsonFile, writeJsonFileAtomic } from './io.js';
+let daemonStarted = false;
+let daemonTimer;
+let daemonConfig;
+export async function startClockDaemonIfNeeded(config) {
+    if (daemonStarted) {
+        return;
+    }
+    const sessionDir = readSessionDirEnv();
+    if (!sessionDir) {
+        return;
+    }
+    daemonStarted = true;
+    daemonConfig = config;
+    const tickOnce = async () => {
+        const effective = daemonConfig;
+        if (!effective)
+            return;
+        const base = readSessionDirEnv();
+        if (!base)
+            return;
+        const dir = resolveClockDir(base);
+        try {
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            const at = nowMs();
+            for (const entry of entries) {
+                if (!entry.isFile())
+                    continue;
+                if (!entry.name.endsWith('.json'))
+                    continue;
+                const filePath = path.join(dir, entry.name);
+                try {
+                    const raw = await readJsonFile(filePath);
+                    const sessionId = entry.name.slice(0, -'.json'.length);
+                    const state = coerceState(raw, sessionId);
+                    const cleaned = cleanExpiredTasks(state.tasks, effective, at);
+                    if (!cleaned.length) {
+                        await fs.rm(filePath, { force: true });
+                        continue;
+                    }
+                    if (cleaned.length !== state.tasks.length) {
+                        const next = {
+                            ...state,
+                            tasks: cleaned,
+                            updatedAtMs: at
+                        };
+                        await writeJsonFileAtomic(filePath, next);
+                    }
+                }
+                catch {
+                    // best-effort: ignore per-file errors
+                }
+            }
+        }
+        catch {
+            // best-effort: ignore global scan errors
+        }
+    };
+    // Startup scan (best-effort).
+    void tickOnce();
+    if (config.tickMs > 0) {
+        daemonTimer = setInterval(() => {
+            void tickOnce();
+        }, config.tickMs);
+        daemonTimer.unref?.();
+    }
+}
+export async function stopClockDaemonForTests() {
+    if (daemonTimer) {
+        clearInterval(daemonTimer);
+        daemonTimer = undefined;
+    }
+    daemonStarted = false;
+    daemonConfig = undefined;
+}

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

@@ -0,0 +1,2 @@
+export declare function readJsonFile(filePath: string): Promise<unknown>;
+export declare function writeJsonFileAtomic(filePath: string, value: unknown): Promise<void>;

package/dist/servertool/clock/io.js

@@ -0,0 +1,13 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export async function readJsonFile(filePath) {
+    const buf = await fs.readFile(filePath);
+    return JSON.parse(buf.toString('utf8'));
+}
+export async function writeJsonFileAtomic(filePath, value) {
+    const dir = path.dirname(filePath);
+    const tmp = path.join(dir, `.tmp_${path.basename(filePath)}_${process.pid}_${Date.now()}_${Math.random().toString(16).slice(2)}`);
+    const payload = JSON.stringify(value, null, 2);
+    await fs.writeFile(tmp, payload, 'utf8');
+    await fs.rename(tmp, filePath);
+}

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

@@ -0,0 +1,4 @@
+export declare function readSessionDirEnv(): string;
+export declare function resolveClockDir(sessionDir: string): string;
+export declare function resolveClockStateFile(sessionDir: string, sessionId: string): string | null;
+export declare function ensureDir(dir: string): Promise<void>;

package/dist/servertool/clock/paths.js

@@ -0,0 +1,25 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export function readSessionDirEnv() {
+    return String(process.env.ROUTECODEX_SESSION_DIR || '').trim();
+}
+function sanitizeSegment(value) {
+    return String(value || '')
+        .trim()
+        .replace(/[^a-zA-Z0-9_.-]/g, '_')
+        .replace(/_+/g, '_')
+        .replace(/^_+|_+$/g, '');
+}
+export function resolveClockDir(sessionDir) {
+    return path.join(sessionDir, 'clock');
+}
+export function resolveClockStateFile(sessionDir, sessionId) {
+    const safe = sanitizeSegment(sessionId);
+    if (!safe) {
+        return null;
+    }
+    return path.join(resolveClockDir(sessionDir), `${safe}.json`);
+}
+export async function ensureDir(dir) {
+    await fs.mkdir(dir, { recursive: true });
+}

package/dist/servertool/clock/session-store.d.ts

@@ -0,0 +1,3 @@
+import type { ClockConfigSnapshot, ClockSessionState } from './types.js';
+export declare function loadClockSessionState(sessionId: string, config: ClockConfigSnapshot): Promise<ClockSessionState>;
+export declare function clearClockSession(sessionId: string): Promise<void>;