@jsonstudio/llms 0.6.1462 → 0.6.1733

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/message-utils.js

@@ -59,8 +59,8 @@ export function detectExtendedThinkingKeyword(text) {
 export function detectImageAttachment(message) {
     if (!message)
         return false;
-    // 仅基于标准 Chat 语义判断是否携带图片：
-    // - content 为数组时查找 { type: 'image' | 'image_url' | 'input_image', ... } 块；
+    // 仅基于标准 Chat 语义判断是否携带视觉媒体（图片/视频）：
+    // - content 为数组时查找 { type: 'image' | 'image_url' | 'input_image' | 'video' | 'video_url' | 'input_video', ... } 块；
     // - 不再依赖 metadata.attachments，也不再用纯文本关键字或剪贴板标记作为信号。
     if (Array.isArray(message.content)) {
         for (const part of message.content) {
@@ -69,19 +69,29 @@ export function detectImageAttachment(message) {
             }
             const record = part;
             const typeValue = typeof record.type === 'string' ? record.type.toLowerCase() : '';
-            // For chat/standardized content, images may appear as:
+            // For chat/standardized content, media may appear as:
             // - { type: "image_url", image_url: { url } }
             // - { type: "image", uri: "...", data: "...", url: "..." }
             // - { type: "input_image", image_url: "data:..." }
-            // Treat any non-empty URL/URI/data on an image-* block as a signal.
+            // - { type: "video_url", video_url: { url } }
+            // - { type: "video", uri: "...", data: "...", url: "..." }
+            // - { type: "input_video", video_url: "data:..." }
+            // Treat any non-empty URL/URI/data on a media-* block as a signal.
             let imageCandidate = '';
             if (typeof record.image_url === 'string') {
                 imageCandidate = record.image_url ?? '';
             }
+            else if (typeof record.video_url === 'string') {
+                imageCandidate = record.video_url ?? '';
+            }
             else if (record.image_url &&
                 typeof record.image_url?.url === 'string') {
                 imageCandidate = record.image_url?.url ?? '';
             }
+            else if (record.video_url &&
+                typeof record.video_url?.url === 'string') {
+                imageCandidate = record.video_url?.url ?? '';
+            }
             else if (typeof record.url === 'string') {
                 imageCandidate = record.url ?? '';
             }
@@ -91,7 +101,7 @@ export function detectImageAttachment(message) {
             else if (typeof record.data === 'string') {
                 imageCandidate = record.data ?? '';
             }
-            if (typeValue.includes('image') && imageCandidate.trim().length > 0) {
+            if ((typeValue.includes('image') || typeValue.includes('video')) && imageCandidate.trim().length > 0) {
                 return true;
             }
         }

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)

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

@@ -0,0 +1,18 @@
+import type { ClockConfigSnapshot, ClockNtpState } from './types.js';
+export declare function resolveServerTimezone(): string;
+export declare function formatLocalTime(ms: number): string;
+export declare function buildTimeTagLine(snapshot: ClockTimeSnapshot): string;
+export type ClockTimeSnapshot = {
+    active: boolean;
+    nowMs: number;
+    utc: string;
+    local: string;
+    timezone: string;
+    ntp: ClockNtpState;
+};
+export declare function syncClockWithNtpOnce(): Promise<void>;
+export declare function startClockNtpSyncIfNeeded(_config?: ClockConfigSnapshot): Promise<void>;
+export declare function getClockNtpState(): Promise<ClockNtpState>;
+export declare function getClockTimeSnapshot(): Promise<ClockTimeSnapshot>;
+export declare function getCurrentClockOffsetMs(): number;
+export declare function buildStableToolCallId(prefix?: string): string;

package/dist/servertool/clock/ntp.js

@@ -0,0 +1,318 @@
+import dgram from 'node:dgram';
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { ensureDir, readSessionDirEnv, resolveClockNtpStateFile } from './paths.js';
+import { readJsonFile, writeJsonFileAtomic } from './io.js';
+import { getClockOffsetMs, setClockOffsetMs, nowMs as correctedNowMs } from './state.js';
+const DEFAULT_NTP_SERVERS = ['time.google.com', 'time.cloudflare.com', 'pool.ntp.org'];
+function isNtpDisabledByEnv() {
+    const raw = String(process.env.ROUTECODEX_CLOCK_NTP || '').trim().toLowerCase();
+    if (!raw)
+        return false;
+    return raw === '0' || raw === 'false' || raw === 'off' || raw === 'disable' || raw === 'disabled';
+}
+function clampNumber(value, min, max) {
+    if (!Number.isFinite(value))
+        return min;
+    return Math.max(min, Math.min(max, value));
+}
+function safeErrorMessage(err) {
+    try {
+        if (err instanceof Error)
+            return err.message || err.name;
+        return String(err ?? 'unknown');
+    }
+    catch {
+        return 'unknown';
+    }
+}
+function pad2(n) {
+    return n < 10 ? `0${n}` : String(n);
+}
+function pad3(n) {
+    if (n < 10)
+        return `00${n}`;
+    if (n < 100)
+        return `0${n}`;
+    return String(n);
+}
+function formatOffset(minutesEast) {
+    const sign = minutesEast >= 0 ? '+' : '-';
+    const abs = Math.abs(minutesEast);
+    const hh = Math.floor(abs / 60);
+    const mm = abs % 60;
+    return `${sign}${pad2(hh)}:${pad2(mm)}`;
+}
+export function resolveServerTimezone() {
+    try {
+        const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+        return typeof tz === 'string' && tz.trim().length ? tz.trim() : 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+export function formatLocalTime(ms) {
+    const d = new Date(ms);
+    const y = d.getFullYear();
+    const mo = pad2(d.getMonth() + 1);
+    const da = pad2(d.getDate());
+    const hh = pad2(d.getHours());
+    const mi = pad2(d.getMinutes());
+    const ss = pad2(d.getSeconds());
+    const mmm = pad3(d.getMilliseconds());
+    const minutesEast = -d.getTimezoneOffset();
+    return `${y}-${mo}-${da} ${hh}:${mi}:${ss}.${mmm} ${formatOffset(minutesEast)}`;
+}
+export function buildTimeTagLine(snapshot) {
+    // Markdown inline code blocks to reduce the chance of models "roleplaying" XML-like tags.
+    return `[Time/Date]: utc=\`${snapshot.utc}\` local=\`${snapshot.local}\` tz=\`${snapshot.timezone}\` nowMs=\`${snapshot.nowMs}\` ntpOffsetMs=\`${snapshot.ntp.offsetMs}\``;
+}
+const EMPTY_NTP_STATE = {
+    version: 1,
+    offsetMs: 0,
+    updatedAtMs: 0,
+    status: 'stale'
+};
+let loaded = false;
+let state = { ...EMPTY_NTP_STATE };
+let syncing = null;
+function coerceNtpState(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return { ...EMPTY_NTP_STATE };
+    }
+    const r = raw;
+    const offsetMs = typeof r.offsetMs === 'number' && Number.isFinite(r.offsetMs) ? Math.floor(r.offsetMs) : 0;
+    const updatedAtMs = typeof r.updatedAtMs === 'number' && Number.isFinite(r.updatedAtMs) ? Math.floor(r.updatedAtMs) : 0;
+    const statusRaw = typeof r.status === 'string' ? r.status.trim() : '';
+    const status = statusRaw === 'synced' || statusRaw === 'stale' || statusRaw === 'error' || statusRaw === 'disabled'
+        ? statusRaw
+        : updatedAtMs > 0
+            ? 'stale'
+            : 'stale';
+    const source = typeof r.source === 'string' && r.source.trim().length ? r.source.trim() : undefined;
+    const rttMs = typeof r.rttMs === 'number' && Number.isFinite(r.rttMs) ? Math.max(0, Math.floor(r.rttMs)) : undefined;
+    const lastError = typeof r.lastError === 'string' && r.lastError.trim().length ? r.lastError.trim() : undefined;
+    return { version: 1, offsetMs, updatedAtMs, status, ...(source ? { source } : {}), ...(rttMs !== undefined ? { rttMs } : {}), ...(lastError ? { lastError } : {}) };
+}
+async function loadStateOnce() {
+    if (loaded)
+        return;
+    loaded = true;
+    if (isNtpDisabledByEnv()) {
+        state = { ...EMPTY_NTP_STATE, status: 'disabled' };
+        setClockOffsetMs(0);
+        return;
+    }
+    const sessionDir = readSessionDirEnv();
+    if (!sessionDir) {
+        state = { ...EMPTY_NTP_STATE, status: 'stale' };
+        setClockOffsetMs(0);
+        return;
+    }
+    const filePath = resolveClockNtpStateFile(sessionDir);
+    try {
+        const raw = await readJsonFile(filePath);
+        state = coerceNtpState(raw);
+        setClockOffsetMs(state.offsetMs);
+    }
+    catch {
+        // missing/unreadable file: keep defaults
+        state = { ...EMPTY_NTP_STATE, status: 'stale' };
+        setClockOffsetMs(0);
+    }
+}
+async function persistState(next) {
+    const sessionDir = readSessionDirEnv();
+    if (!sessionDir)
+        return;
+    const filePath = resolveClockNtpStateFile(sessionDir);
+    await ensureDir(path.dirname(filePath));
+    try {
+        await fs.chmod(path.dirname(filePath), 0o700);
+    }
+    catch {
+        // best-effort
+    }
+    await writeJsonFileAtomic(filePath, next);
+}
+const NTP_EPOCH_OFFSET_SECONDS = 2208988800; // 1900-01-01 to 1970-01-01
+function msToNtpTimestamp(ms) {
+    const seconds = Math.floor(ms / 1000) + NTP_EPOCH_OFFSET_SECONDS;
+    const msRemainder = ms % 1000;
+    const fraction = Math.floor((msRemainder / 1000) * 2 ** 32);
+    return { seconds, fraction };
+}
+function ntpTimestampToMs(seconds, fraction) {
+    const unixSeconds = seconds - NTP_EPOCH_OFFSET_SECONDS;
+    const fracMs = Math.round((fraction / 2 ** 32) * 1000);
+    return unixSeconds * 1000 + fracMs;
+}
+async function querySntpOnce(server, timeoutMs) {
+    const socket = dgram.createSocket('udp4');
+    const req = Buffer.alloc(48);
+    req[0] = 0x23; // LI=0, VN=4, Mode=3 (client)
+    const t1SystemMs = Date.now();
+    const t1 = msToNtpTimestamp(t1SystemMs);
+    req.writeUInt32BE(t1.seconds >>> 0, 40);
+    req.writeUInt32BE(t1.fraction >>> 0, 44);
+    const res = await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            reject(new Error('ntp timeout'));
+        }, timeoutMs);
+        socket.once('error', (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+        socket.once('message', (msg) => {
+            clearTimeout(timer);
+            resolve(msg);
+        });
+        socket.send(req, 123, server, (err) => {
+            if (err) {
+                clearTimeout(timer);
+                reject(err);
+            }
+        });
+    }).finally(() => {
+        try {
+            socket.close();
+        }
+        catch {
+            // ignore
+        }
+    });
+    if (!Buffer.isBuffer(res) || res.length < 48) {
+        throw new Error('invalid ntp response');
+    }
+    const t4SystemMs = Date.now();
+    const t2Seconds = res.readUInt32BE(32);
+    const t2Fraction = res.readUInt32BE(36);
+    const t3Seconds = res.readUInt32BE(40);
+    const t3Fraction = res.readUInt32BE(44);
+    const t2Ms = ntpTimestampToMs(t2Seconds, t2Fraction);
+    const t3Ms = ntpTimestampToMs(t3Seconds, t3Fraction);
+    const offsetMs = ((t2Ms - t1SystemMs) + (t3Ms - t4SystemMs)) / 2;
+    const rttMs = (t4SystemMs - t1SystemMs) - (t3Ms - t2Ms);
+    return {
+        offsetMs: Math.floor(clampNumber(offsetMs, -24 * 60 * 60_000, 24 * 60 * 60_000)),
+        rttMs: Math.max(0, Math.floor(rttMs))
+    };
+}
+function resolveNtpServers() {
+    const raw = String(process.env.ROUTECODEX_CLOCK_NTP_SERVERS || '').trim();
+    if (!raw)
+        return [...DEFAULT_NTP_SERVERS];
+    const list = raw.split(',').map((s) => s.trim()).filter(Boolean);
+    return list.length ? list : [...DEFAULT_NTP_SERVERS];
+}
+export async function syncClockWithNtpOnce() {
+    await loadStateOnce();
+    if (isNtpDisabledByEnv()) {
+        state = { ...state, status: 'disabled', offsetMs: 0 };
+        setClockOffsetMs(0);
+        return;
+    }
+    const servers = resolveNtpServers();
+    const timeoutMs = (() => {
+        const raw = Number(process.env.ROUTECODEX_CLOCK_NTP_TIMEOUT_MS ?? 800);
+        return Number.isFinite(raw) ? Math.max(100, Math.floor(raw)) : 800;
+    })();
+    let lastErr;
+    for (const server of servers.slice(0, 5)) {
+        try {
+            const result = await querySntpOnce(server, timeoutMs);
+            const updatedAtMs = Date.now();
+            const next = {
+                version: 1,
+                offsetMs: result.offsetMs,
+                updatedAtMs,
+                source: server,
+                rttMs: result.rttMs,
+                status: 'synced'
+            };
+            state = next;
+            setClockOffsetMs(result.offsetMs);
+            await persistState(next);
+            return;
+        }
+        catch (err) {
+            lastErr = safeErrorMessage(err);
+        }
+    }
+    state = {
+        ...state,
+        status: 'error',
+        lastError: lastErr || 'ntp failed',
+        updatedAtMs: state.updatedAtMs || Date.now()
+    };
+}
+export async function startClockNtpSyncIfNeeded(_config) {
+    await loadStateOnce();
+    if (isNtpDisabledByEnv())
+        return;
+    if (syncing)
+        return syncing;
+    // Best-effort background sync; do not block the request pipeline.
+    syncing = (async () => {
+        try {
+            await syncClockWithNtpOnce();
+        }
+        catch {
+            // best-effort
+        }
+        finally {
+            syncing = null;
+        }
+    })();
+    return syncing;
+}
+export async function getClockNtpState() {
+    await loadStateOnce();
+    const now = Date.now();
+    const staleAfterMs = (() => {
+        const raw = Number(process.env.ROUTECODEX_CLOCK_NTP_STALE_AFTER_MS ?? 6 * 60 * 60_000);
+        return Number.isFinite(raw) ? Math.max(60_000, Math.floor(raw)) : 6 * 60 * 60_000;
+    })();
+    const age = state.updatedAtMs > 0 ? Math.max(0, now - state.updatedAtMs) : Number.POSITIVE_INFINITY;
+    if (state.status === 'synced' && age > staleAfterMs) {
+        return { ...state, status: 'stale' };
+    }
+    return { ...state };
+}
+export async function getClockTimeSnapshot() {
+    await loadStateOnce();
+    const now = correctedNowMs();
+    const d = new Date(now);
+    const utc = (() => {
+        try {
+            return d.toISOString();
+        }
+        catch {
+            return new Date(0).toISOString();
+        }
+    })();
+    const timezone = resolveServerTimezone();
+    const local = formatLocalTime(now);
+    const ntp = await getClockNtpState();
+    return {
+        active: true,
+        nowMs: now,
+        utc,
+        local,
+        timezone,
+        ntp
+    };
+}
+export function getCurrentClockOffsetMs() {
+    return getClockOffsetMs();
+}
+export function buildStableToolCallId(prefix = 'call_clock') {
+    try {
+        return `${prefix}_${crypto.randomUUID()}`;
+    }
+    catch {
+        return `${prefix}_${Date.now()}_${Math.random().toString(16).slice(2)}`;
+    }
+}

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

@@ -1,4 +1,5 @@
 export declare function readSessionDirEnv(): string;
 export declare function resolveClockDir(sessionDir: string): string;
+export declare function resolveClockNtpStateFile(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

@@ -13,6 +13,9 @@ function sanitizeSegment(value) {
 export function resolveClockDir(sessionDir) {
     return path.join(sessionDir, 'clock');
 }
+export function resolveClockNtpStateFile(sessionDir) {
+    return path.join(resolveClockDir(sessionDir), 'ntp-state.json');
+}
 export function resolveClockStateFile(sessionDir, sessionId) {
     const safe = sanitizeSegment(sessionId);
     if (!safe) {

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

@@ -1,4 +1,6 @@
 import type { ClockConfigSnapshot, ClockSessionState, ClockTask } from './types.js';
+export declare function setClockOffsetMs(value: number): void;
+export declare function getClockOffsetMs(): number;
 export declare function nowMs(): number;
 export declare function buildEmptyState(sessionId: string): ClockSessionState;
 export declare function coerceState(raw: unknown, sessionId: string): ClockSessionState;

package/dist/servertool/clock/state.js

@@ -1,5 +1,14 @@
+let clockOffsetMs = 0;
+export function setClockOffsetMs(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return;
+    clockOffsetMs = Math.max(-24 * 60 * 60_000, Math.min(24 * 60 * 60_000, Math.floor(value)));
+}
+export function getClockOffsetMs() {
+    return clockOffsetMs;
+}
 export function nowMs() {
-    return Date.now();
+    return Date.now() + clockOffsetMs;
 }
 export function buildEmptyState(sessionId) {
     const t = nowMs();
@@ -29,6 +38,9 @@ export function coerceState(raw, sessionId) {
             ? e.arguments
             : undefined;
         const deliveredAtMs = typeof e.deliveredAtMs === 'number' && Number.isFinite(e.deliveredAtMs) ? Math.floor(e.deliveredAtMs) : undefined;
+        const notBeforeRequestId = typeof e.notBeforeRequestId === 'string' && e.notBeforeRequestId.trim().length
+            ? e.notBeforeRequestId.trim()
+            : undefined;
         const deliveryCount = typeof e.deliveryCount === 'number' && Number.isFinite(e.deliveryCount) ? Math.max(0, Math.floor(e.deliveryCount)) : 0;
         tasks.push({
             taskId,
@@ -40,7 +52,8 @@ export function coerceState(raw, sessionId) {
             ...(tool ? { tool } : {}),
             ...(args ? { arguments: args } : {}),
             ...(deliveredAtMs !== undefined ? { deliveredAtMs } : {}),
-            deliveryCount
+            deliveryCount,
+            ...(notBeforeRequestId ? { notBeforeRequestId } : {})
         });
     }
     const updatedAtMs = typeof record.updatedAtMs === 'number' && Number.isFinite(record.updatedAtMs) ? Math.floor(record.updatedAtMs) : nowMs();

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

@@ -10,6 +10,7 @@ export declare function reserveDueTasksForRequest(args: {
     reservationId: string;
     sessionId: string;
     config: ClockConfigSnapshot;
+    requestId?: string;
 }): Promise<{
     reservation: ClockReservation | null;
     injectText?: string;