@jsonstudio/llms 0.6.1449 → 0.6.1643

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;

package/dist/servertool/clock/tasks.js

@@ -71,6 +71,7 @@ export async function scheduleClockTasks(sessionId, items, config) {
             task: text,
             ...(item.tool ? { tool: item.tool } : {}),
             ...(item.arguments ? { arguments: item.arguments } : {}),
+            ...(item.notBeforeRequestId ? { notBeforeRequestId: item.notBeforeRequestId } : {}),
             deliveryCount: 0
         });
     }
@@ -125,6 +126,10 @@ export function selectDueUndeliveredTasks(tasks, config, atMs) {
             continue;
         if (task.deliveredAtMs !== undefined)
             continue;
+        if (typeof task.notBeforeRequestId === 'string' && task.notBeforeRequestId.trim().length) {
+            // notBeforeRequestId is evaluated by reserveDueTasksForRequest, which passes requestId.
+            // Keep legacy callers working by ignoring this guard here (default behavior).
+        }
         if (!Number.isFinite(task.dueAtMs))
             continue;
         if (atMs < task.dueAtMs - config.dueWindowMs)
@@ -157,7 +162,25 @@ export function findNextUndeliveredDueAtMs(tasks, atMs) {
 export async function reserveDueTasksForRequest(args) {
     const state = await loadClockSessionState(args.sessionId, args.config);
     const at = nowMs();
-    const due = selectDueUndeliveredTasks(state.tasks, args.config, at);
+    const dueAll = selectDueUndeliveredTasks(state.tasks, args.config, at);
+    const requestId = typeof args.requestId === 'string' && args.requestId.trim().length ? args.requestId.trim() : '';
+    const isSameRequestChain = (guardedRequestId, currentRequestId) => {
+        const guarded = guardedRequestId.trim();
+        if (!guarded)
+            return false;
+        return currentRequestId === guarded || currentRequestId.startsWith(`${guarded}:`);
+    };
+    const due = requestId
+        ? dueAll.filter((t) => {
+            const guarded = typeof t.notBeforeRequestId === 'string' ? String(t.notBeforeRequestId).trim() : '';
+            if (!guarded) {
+                return true;
+            }
+            // Avoid same-request triggers, including internal followups that suffix the requestId
+            // (e.g. ":clock_followup"), to prevent request-local dead loops.
+            return !isSameRequestChain(guarded, requestId);
+        })
+        : dueAll;
     if (!due.length) {
         return { reservation: null };
     }

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

@@ -9,6 +9,7 @@ export type ClockTask = {
     arguments?: Record<string, unknown>;
     deliveredAtMs?: number;
     deliveryCount: number;
+    notBeforeRequestId?: string;
 };
 export type ClockSessionState = {
     version: 1;
@@ -27,10 +28,30 @@ export type ClockConfigSnapshot = {
     retentionMs: number;
     dueWindowMs: number;
     tickMs: number;
+    /**
+     * Whether clock_hold_flow is allowed for non-streaming (JSON) clients.
+     * Default: true (best-effort long-poll hold; clients can abort the connection).
+     */
+    holdNonStreaming: boolean;
+    /**
+     * Maximum time (ms) a single request is allowed to hold before followup.
+     * Default: 60s. Larger values increase resource usage and risk client/proxy timeouts.
+     */
+    holdMaxMs: number;
 };
 export type ClockScheduleItem = {
     dueAtMs: number;
     task: string;
     tool?: string;
     arguments?: Record<string, unknown>;
+    notBeforeRequestId?: string;
+};
+export type ClockNtpState = {
+    version: 1;
+    offsetMs: number;
+    updatedAtMs: number;
+    source?: string;
+    rttMs?: number;
+    status: 'synced' | 'stale' | 'error' | 'disabled';
+    lastError?: string;
 };

package/dist/servertool/engine.js

@@ -5,7 +5,7 @@ import { createHash } from 'node:crypto';
 import { loadRoutingInstructionStateSync, saveRoutingInstructionStateSync } from '../router/virtual-router/sticky-session-store.js';
 import { deserializeRoutingInstructionState, serializeRoutingInstructionState } from '../router/virtual-router/routing-instructions.js';
 import { applyHubFollowupPolicyShadow } from './followup-shadow.js';
-import { buildServerToolFollowupChatPayloadFromInjection } from './handlers/followup-request-builder.js';
+import { buildServerToolFollowupChatPayloadFromInjection, extractCapturedChatSeed } from './handlers/followup-request-builder.js';
 import { findNextUndeliveredDueAtMs, listClockTasks, resolveClockConfig } from './clock/task-store.js';
 import { savePendingServerToolInjection } from './pending-session.js';
 function parseTimeoutMs(raw, fallback) {
@@ -277,12 +277,32 @@ export async function runServerToolOrchestration(options) {
         timeoutMs: effectiveServerToolTimeoutMs || serverToolTimeoutMs
     }));
     if (engineResult.mode === 'passthrough' || !engineResult.execution) {
+        try {
+            options.stageRecorder?.record('servertool.match', {
+                matched: false,
+                mode: engineResult.mode,
+                reason: engineResult.mode === 'passthrough' ? 'passthrough' : 'no_execution'
+            });
+        }
+        catch {
+            // best-effort only
+        }
         return {
             chat: engineResult.finalChatResponse,
             executed: false
         };
     }
     const flowId = engineResult.execution.flowId ?? 'unknown';
+    try {
+        options.stageRecorder?.record('servertool.match', {
+            matched: true,
+            flowId,
+            hasFollowup: Boolean(engineResult.execution.followup)
+        });
+    }
+    catch {
+        // best-effort only
+    }
     const totalSteps = 5;
     logProgress(1, totalSteps, 'matched', { flowId });
     // Mixed tools: persist servertool outputs for next request, but return remaining tool_calls to client.
@@ -513,6 +533,90 @@ export async function runServerToolOrchestration(options) {
         wrapped.cause = lastError;
         throw wrapped;
     }
+    // Special case: Antigravity thoughtSignature bootstrap flow.
+    // - First followup performs a minimal preflight (forces clock.get) to obtain a fresh signature.
+    // - If preflight succeeds, immediately replay the original captured request as a second internal hop,
+    //   so the client sees a single recovered response (transparent).
+    if (engineResult.execution.flowId === 'antigravity_thought_signature_bootstrap' && options.reenterPipeline) {
+        const preflight = followupBody;
+        const preflightError = preflight && typeof preflight.error === 'object' ? preflight.error : null;
+        const preflightStatus = (() => {
+            if (!preflightError || typeof preflightError !== 'object' || Array.isArray(preflightError))
+                return undefined;
+            const statusRaw = preflightError.status ?? preflightError.statusCode;
+            if (typeof statusRaw === 'number' && Number.isFinite(statusRaw))
+                return Math.floor(statusRaw);
+            const codeRaw = preflightError.code;
+            const code = typeof codeRaw === 'string' ? codeRaw.trim() : typeof codeRaw === 'number' ? String(codeRaw) : '';
+            if (code && /^HTTP_\d{3}$/i.test(code))
+                return Number(code.split('_')[1]);
+            if (code && /^\d{3}$/.test(code))
+                return Number(code);
+            return undefined;
+        })();
+        // One-shot guard: if preflight still looks rate-limited / invalid, stop and return the original error.
+        if (preflightError && (preflightStatus === 429 || preflightStatus === 400)) {
+            const decorated = decorateFinalChatWithServerToolContext(engineResult.finalChatResponse, engineResult.execution);
+            logProgress(5, totalSteps, 'completed (bootstrap preflight failed)', { flowId });
+            return { chat: decorated, executed: true, flowId: engineResult.execution.flowId };
+        }
+        const replaySeed = extractCapturedChatSeed(options.adapterContext?.capturedChatRequest);
+        if (replaySeed) {
+            const replayPayload = {
+                ...(replaySeed.model ? { model: replaySeed.model } : {}),
+                messages: Array.isArray(replaySeed.messages) ? replaySeed.messages : [],
+                ...(Array.isArray(replaySeed.tools) ? { tools: replaySeed.tools } : {}),
+                ...(replaySeed.parameters && typeof replaySeed.parameters === 'object' && !Array.isArray(replaySeed.parameters)
+                    ? { parameters: replaySeed.parameters }
+                    : {})
+            };
+            const replayLoopState = buildServerToolLoopState(options.adapterContext, engineResult.execution.flowId, replayPayload);
+            const replayMetadata = { stream: false };
+            const replayRt = ensureRuntimeMetadata(replayMetadata);
+            replayRt.serverToolFollowup = true;
+            if (replayLoopState) {
+                replayRt.serverToolLoopState = replayLoopState;
+            }
+            replayMetadata.__hubEntry = 'chat_process';
+            replayMetadata.routeHint = '';
+            replayRt.preserveRouteHint = false;
+            replayRt.disableStickyRoutes = true;
+            replayRt.serverToolOriginalEntryEndpoint =
+                (typeof options.entryEndpoint === 'string' && options.entryEndpoint.trim().length
+                    ? options.entryEndpoint
+                    : followupEntryEndpoint);
+            const forcedProviderKeyRaw = options.adapterContext?.providerKey;
+            const forcedProviderKey = typeof forcedProviderKeyRaw === 'string' && forcedProviderKeyRaw.trim().length ? forcedProviderKeyRaw.trim() : '';
+            if (forcedProviderKey) {
+                replayMetadata.__shadowCompareForcedProviderKey = forcedProviderKey;
+            }
+            const replayRequestId = buildFollowupRequestId(options.requestId, ':antigravity_ts_replay');
+            const replayPayloadFinal = applyHubFollowupPolicyShadow({
+                requestId: replayRequestId,
+                entryEndpoint: followupEntryEndpoint,
+                flowId: engineResult.execution.flowId,
+                payload: coerceFollowupPayloadStream(replayPayload, false),
+                stageRecorder: options.stageRecorder
+            });
+            const replayResult = await withTimeout(options.reenterPipeline({
+                entryEndpoint: followupEntryEndpoint,
+                requestId: replayRequestId,
+                body: replayPayloadFinal,
+                metadata: replayMetadata
+            }), followupTimeoutMs, () => createServerToolTimeoutError({
+                requestId: options.requestId,
+                phase: 'followup',
+                timeoutMs: followupTimeoutMs,
+                flowId: engineResult.execution.flowId
+            }));
+            const replayBody = replayResult && replayResult.body && typeof replayResult.body === 'object'
+                ? replayResult.body
+                : undefined;
+            const decorated = decorateFinalChatWithServerToolContext(replayBody ?? preflight ?? engineResult.finalChatResponse, engineResult.execution);
+            logProgress(5, totalSteps, 'completed (bootstrap replay)', { flowId });
+            return { chat: decorated, executed: true, flowId: engineResult.execution.flowId };
+        }
+    }
     const decorated = decorateFinalChatWithServerToolContext(followupBody ?? engineResult.finalChatResponse, engineResult.execution);
     logProgress(5, totalSteps, 'completed', { flowId });
     return {

package/dist/servertool/handlers/antigravity-thought-signature-bootstrap.d.ts

@@ -0,0 +1 @@
+export {};