@jsonstudio/llms 0.6.1739 → 0.6.1890

package/dist/servertool/engine.js

@@ -8,6 +8,12 @@ import { applyHubFollowupPolicyShadow } from './followup-shadow.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';
+import { appendServerToolProgressFileEvent } from './log/progress-file.js';
+import { attachStopGatewayContext, inspectStopGatewaySignal } from './stop-gateway-context.js';
+import { formatStopMessageCompareContext, readStopMessageCompareContext } from './stop-message-compare-context.js';
+const STOP_MESSAGE_STAGE_TIMEOUT_MS = 900_000;
+const STOP_MESSAGE_LOOP_WARN_THRESHOLD = 5;
+const STOP_MESSAGE_LOOP_FAIL_THRESHOLD = 10;
 function parseTimeoutMs(raw, fallback) {
     const n = typeof raw === 'string' ? Number(raw.trim()) : typeof raw === 'number' ? raw : NaN;
     if (!Number.isFinite(n) || n <= 0) {
@@ -63,6 +69,36 @@ function createServerToolTimeoutError(options) {
     err.status = 504;
     return err;
 }
+function createStopMessageFetchFailedError(options) {
+    const baseMessage = options.reason === 'loop_limit'
+        ? 'fetch failed: network error (stopMessage loop detected)'
+        : 'fetch failed: network error (stopMessage exceeded stage timeout)';
+    const err = new ProviderProtocolError(baseMessage, {
+        code: 'SERVERTOOL_TIMEOUT',
+        category: 'EXTERNAL_ERROR',
+        details: {
+            requestId: options.requestId,
+            reason: options.reason,
+            ...(typeof options.elapsedMs === 'number' && Number.isFinite(options.elapsedMs)
+                ? { elapsedMs: Math.max(0, Math.floor(options.elapsedMs)) }
+                : {}),
+            ...(typeof options.repeatCount === 'number' && Number.isFinite(options.repeatCount)
+                ? { repeatCount: Math.max(0, Math.floor(options.repeatCount)) }
+                : {}),
+            ...(typeof options.timeoutMs === 'number' && Number.isFinite(options.timeoutMs)
+                ? { timeoutMs: Math.max(0, Math.floor(options.timeoutMs)) }
+                : {}),
+            ...(typeof options.attempt === 'number' && Number.isFinite(options.attempt)
+                ? { attempt: Math.max(1, Math.floor(options.attempt)) }
+                : {}),
+            ...(typeof options.maxAttempts === 'number' && Number.isFinite(options.maxAttempts)
+                ? { maxAttempts: Math.max(1, Math.floor(options.maxAttempts)) }
+                : {})
+        }
+    });
+    err.status = 502;
+    return err;
+}
 function coerceFollowupPayloadStream(payload, stream) {
     if (!payload || typeof payload !== 'object') {
         return payload;
@@ -159,49 +195,7 @@ function isEmptyClientResponsePayload(payload) {
     return true;
 }
 function isStopFinishReasonWithoutToolCalls(base) {
-    if (!base || typeof base !== 'object' || Array.isArray(base)) {
-        return false;
-    }
-    const payload = base;
-    const choicesRaw = payload.choices;
-    if (Array.isArray(choicesRaw) && choicesRaw.length) {
-        const first = choicesRaw[0];
-        if (!first || typeof first !== 'object' || Array.isArray(first)) {
-            return false;
-        }
-        const finishReasonRaw = first.finish_reason;
-        const finishReason = typeof finishReasonRaw === 'string' && finishReasonRaw.trim()
-            ? finishReasonRaw.trim().toLowerCase()
-            : '';
-        if (!finishReason || finishReason === 'tool_calls') {
-            return false;
-        }
-        if (finishReason !== 'stop' && finishReason !== 'length') {
-            return false;
-        }
-        const message = first.message &&
-            typeof first.message === 'object' &&
-            !Array.isArray(first.message)
-            ? first.message
-            : null;
-        if (!message) {
-            return false;
-        }
-        const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
-        if (toolCalls.length > 0) {
-            return false;
-        }
-        return true;
-    }
-    // Responses-like: completed without required_action generally counts as stop.
-    const statusRaw = typeof payload.status === 'string' ? payload.status.trim().toLowerCase() : '';
-    if (statusRaw && statusRaw !== 'completed') {
-        return false;
-    }
-    if (payload.required_action && typeof payload.required_action === 'object') {
-        return false;
-    }
-    return true;
+    return inspectStopGatewaySignal(base).eligible;
 }
 async function shouldDisableServerToolTimeoutForClockHold(args) {
     // Only relevant for stop/length responses: clock_auto may hold indefinitely.
@@ -241,19 +235,183 @@ async function shouldDisableServerToolTimeoutForClockHold(args) {
     }
 }
 export async function runServerToolOrchestration(options) {
+    const BLUE = '\x1b[38;5;39m';
     const YELLOW = '\x1b[38;5;214m';
+    const GOLD = '\x1b[38;5;220m';
     const RESET = '\x1b[0m';
-    const logProgress = (step, total, message, extra) => {
+    const resolveToolName = (flowId) => {
+        const normalized = flowId.trim();
+        if (!normalized)
+            return 'unknown';
+        const mapping = {
+            continue_execution_flow: 'continue_execution',
+            stop_message_flow: 'stop_message_auto',
+            empty_reply_continue: 'empty_reply_continue',
+            apply_patch_guard: 'apply_patch_guard',
+            exec_command_guard: 'exec_command_guard',
+            iflow_model_error_retry: 'iflow_model_error_retry',
+            antigravity_thought_signature_bootstrap: 'antigravity_thought_signature_bootstrap',
+            web_search_flow: 'web_search',
+            vision_flow: 'vision_auto',
+            clock_flow: 'clock',
+            clock_hold_flow: 'clock_auto',
+            recursive_detection_guard: 'recursive_detection_guard'
+        };
+        return mapping[normalized] ?? normalized;
+    };
+    const resolveStage = (step, message) => {
+        const normalized = message.trim().toLowerCase();
+        if (normalized === 'matched' || step <= 1)
+            return 'match';
+        if (normalized.startsWith('completed') || step >= 5)
+            return 'final';
+        return 'followup';
+    };
+    const normalizeResult = (message) => {
+        const normalized = message.trim().toLowerCase();
+        if (!normalized)
+            return 'unknown';
+        const group = /^completed\s*\(([^)]+)\)/.exec(normalized);
+        if (group && group[1]) {
+            return 'completed_' + group[1].trim().replace(/[^a-z0-9]+/g, '_');
+        }
+        return normalized.replace(/[^a-z0-9]+/g, '_').replace(/^_+|_+$/g, '') || 'unknown';
+    };
+    const logStopEntry = (stage, result, extra) => {
+        const color = BLUE;
+        const viewStage = stage === 'trigger' ? 'match' : 'entry';
+        const source = typeof extra?.source === 'string' ? extra.source : 'unknown';
+        const reason = typeof extra?.reason === 'string' ? extra.reason : 'unknown';
+        const eligible = typeof extra?.eligible === 'boolean' ? String(extra.eligible) : 'unknown';
+        const flowId = typeof extra?.flowId === 'string' ? extra.flowId : '';
+        const brief = stage === 'entry'
+            ? `source=${source} reason=${reason} eligible=${eligible}`
+            : `result=${result} flow=${flowId || 'none'}`;
+        try {
+            // eslint-disable-next-line no-console
+            console.log(`${color}[servertool][stop_watch] requestId=${options.requestId} stage=${viewStage} ${brief}${RESET}`);
+        }
+        catch {
+            /* best-effort logging */
+        }
+        appendServerToolProgressFileEvent({
+            requestId: options.requestId,
+            flowId: 'stop_message_flow',
+            tool: 'stop_message_auto',
+            stage,
+            result,
+            message: result,
+            step: stage === 'entry' ? 0 : 2,
+            entryEndpoint: options.entryEndpoint,
+            providerProtocol: options.providerProtocol
+        });
+    };
+    const logProgress = (step, _total, message, extra) => {
+        const flowId = typeof extra?.flowId === 'string' ? extra.flowId.trim() : '';
+        const tool = resolveToolName(flowId);
+        const stage = resolveStage(step, message);
+        const result = normalizeResult(message);
+        const color = flowId === 'continue_execution_flow' ? GOLD : YELLOW;
         try {
             // eslint-disable-next-line no-console
-            console.log(`${YELLOW}[servertool][progress ${step}/${total}] requestId=${options.requestId} ${message}` +
-                (extra ? ` ${JSON.stringify(extra)}` : '') +
-                RESET);
+            console.log(`${color}[servertool] requestId=${options.requestId} tool=${tool} stage=${stage} result=${result}${RESET}`);
         }
         catch {
             /* best-effort logging */
         }
+        appendServerToolProgressFileEvent({
+            requestId: options.requestId,
+            flowId: flowId || 'none',
+            tool,
+            stage,
+            result,
+            message,
+            step,
+            entryEndpoint: options.entryEndpoint,
+            providerProtocol: options.providerProtocol
+        });
+    };
+    const logAutoHookTrace = (event) => {
+        const reasonToken = typeof event.reason === 'string' && event.reason.trim()
+            ? event.reason.trim().toLowerCase().replace(/[^a-z0-9]+/g, '_').replace(/^_+|_+$/g, '')
+            : 'unknown';
+        appendServerToolProgressFileEvent({
+            requestId: options.requestId,
+            flowId: event.flowId || `hook:${event.hookId}`,
+            tool: event.hookId,
+            stage: 'hook',
+            result: `${event.result}_${reasonToken || 'unknown'}`,
+            message: `${event.result} (${event.reason}) queue=${event.queue}[${event.queueIndex}/${event.queueTotal}] phase=${event.phase} priority=${event.priority}`,
+            step: 2,
+            entryEndpoint: options.entryEndpoint,
+            providerProtocol: options.providerProtocol
+        });
+        try {
+            options.stageRecorder?.record('servertool.hook', {
+                hookId: event.hookId,
+                phase: event.phase,
+                priority: event.priority,
+                result: event.result,
+                reason: event.reason,
+                queue: event.queue,
+                queueIndex: event.queueIndex,
+                queueTotal: event.queueTotal,
+                ...(event.flowId ? { flowId: event.flowId } : {})
+            });
+        }
+        catch {
+            // best-effort only
+        }
+    };
+    const logStopCompare = (stage, flowId) => {
+        const compareContext = readStopMessageCompareContext(options.adapterContext);
+        const summary = formatStopMessageCompareContext(compareContext);
+        const viewStage = stage === 'trigger' ? 'match' : 'entry';
+        const flowToken = flowId && flowId.trim() ? flowId.trim() : 'none';
+        try {
+            // eslint-disable-next-line no-console
+            console.log(`${BLUE}[servertool][stop_compare] requestId=${options.requestId} stage=${viewStage} flow=${flowToken} ${summary}${RESET}`);
+        }
+        catch {
+            // best-effort logging
+        }
+        const compareResult = compareContext
+            ? `${compareContext.decision}_${compareContext.reason.toLowerCase().replace(/[^a-z0-9]+/g, '_') || 'unknown'}`
+            : 'unknown_no_context';
+        appendServerToolProgressFileEvent({
+            requestId: options.requestId,
+            flowId: flowToken,
+            tool: 'stop_message_auto',
+            stage: 'compare',
+            result: compareResult,
+            message: summary,
+            step: stage === 'entry' ? 1 : 3,
+            entryEndpoint: options.entryEndpoint,
+            providerProtocol: options.providerProtocol
+        });
+        try {
+            options.stageRecorder?.record('servertool.stop_compare', {
+                stage: viewStage,
+                flowId: flowToken,
+                summary,
+                ...(compareContext ? { compare: compareContext } : {})
+            });
+        }
+        catch {
+            // best-effort only
+        }
     };
+    const stopSignal = inspectStopGatewaySignal(options.chat);
+    attachStopGatewayContext(options.adapterContext, stopSignal);
+    if (stopSignal.observed) {
+        logStopEntry('entry', 'observed', {
+            reason: stopSignal.reason,
+            source: stopSignal.source,
+            eligible: stopSignal.eligible,
+            ...(typeof stopSignal.choiceIndex === 'number' ? { choiceIndex: stopSignal.choiceIndex } : {}),
+            ...(typeof stopSignal.hasToolCalls === 'boolean' ? { hasToolCalls: stopSignal.hasToolCalls } : {})
+        });
+    }
     const serverToolTimeoutMs = resolveServerToolTimeoutMs();
     const shouldDisableTimeout = await shouldDisableServerToolTimeoutForClockHold({
         chat: options.chat,
@@ -269,7 +427,8 @@ export async function runServerToolOrchestration(options) {
         requestId: options.requestId,
         providerProtocol: options.providerProtocol,
         providerInvoker: options.providerInvoker,
-        reenterPipeline: options.reenterPipeline
+        reenterPipeline: options.reenterPipeline,
+        onAutoHookTrace: logAutoHookTrace
     };
     const engineResult = await withTimeout(runServerSideToolEngine(engineOptions), effectiveServerToolTimeoutMs, () => createServerToolTimeoutError({
         requestId: options.requestId,
@@ -277,22 +436,51 @@ export async function runServerToolOrchestration(options) {
         timeoutMs: effectiveServerToolTimeoutMs || serverToolTimeoutMs
     }));
     if (engineResult.mode === 'passthrough' || !engineResult.execution) {
+        const skipReason = engineResult.mode === 'passthrough' ? 'passthrough' : 'no_execution';
+        if (stopSignal.observed) {
+            logStopEntry('trigger', `skipped_${skipReason}`, {
+                reason: stopSignal.reason,
+                source: stopSignal.source,
+                eligible: stopSignal.eligible
+            });
+            logStopCompare('trigger');
+        }
         try {
             options.stageRecorder?.record('servertool.match', {
                 matched: false,
                 mode: engineResult.mode,
-                reason: engineResult.mode === 'passthrough' ? 'passthrough' : 'no_execution'
+                reason: skipReason
             });
         }
         catch {
             // best-effort only
         }
+        appendServerToolProgressFileEvent({
+            requestId: options.requestId,
+            flowId: 'none',
+            tool: 'none',
+            stage: 'match',
+            result: 'skipped_' + skipReason,
+            message: 'skipped (' + skipReason + ')',
+            step: 0,
+            entryEndpoint: options.entryEndpoint,
+            providerProtocol: options.providerProtocol
+        });
         return {
             chat: engineResult.finalChatResponse,
             executed: false
         };
     }
     const flowId = engineResult.execution.flowId ?? 'unknown';
+    if (stopSignal.observed) {
+        logStopEntry('trigger', flowId === 'stop_message_flow' ? 'activated' : 'non_stop_flow', {
+            flowId,
+            reason: stopSignal.reason,
+            source: stopSignal.source,
+            eligible: stopSignal.eligible
+        });
+        logStopCompare('trigger', flowId);
+    }
     try {
         options.stageRecorder?.record('servertool.match', {
             matched: true,
@@ -337,13 +525,12 @@ export async function runServerToolOrchestration(options) {
         };
     }
     const isStopMessageFlow = engineResult.execution.flowId === 'stop_message_flow';
+    const isClockHoldFlow = engineResult.execution.flowId === 'clock_hold_flow';
     const isEmptyReplyContinue = engineResult.execution.flowId === 'empty_reply_continue';
     const isApplyPatchGuard = engineResult.execution.flowId === 'apply_patch_guard';
     const isExecCommandGuard = engineResult.execution.flowId === 'exec_command_guard';
-    const stopMessageSource = isStopMessageFlow ? getStopMessageSource(options.adapterContext) : undefined;
-    const isAutoStopMessage = isStopMessageFlow && stopMessageSource !== 'explicit';
     const isErrorAutoFlow = engineResult.execution.flowId === 'iflow_model_error_retry';
-    const applyAutoLimit = isAutoStopMessage || isErrorAutoFlow || isEmptyReplyContinue || isApplyPatchGuard || isExecCommandGuard;
+    const applyAutoLimit = isErrorAutoFlow || isEmptyReplyContinue || isApplyPatchGuard || isExecCommandGuard;
     // ServerTool followups must not inherit or inject any routeHint; always route fresh.
     const preserveRouteHint = false;
     const followupPlan = engineResult.execution.followup;
@@ -382,7 +569,7 @@ export async function runServerToolOrchestration(options) {
             flowId: engineResult.execution.flowId
         };
     }
-    const loopState = buildServerToolLoopState(options.adapterContext, engineResult.execution.flowId, followupPayloadRaw);
+    const loopState = buildServerToolLoopState(options.adapterContext, engineResult.execution.flowId, followupPayloadRaw, engineResult.finalChatResponse);
     if (applyAutoLimit && loopState && typeof loopState.repeatCount === 'number' && loopState.repeatCount >= 3) {
         logProgress(5, totalSteps, 'completed (auto limit hit)', { flowId });
         return {
@@ -391,6 +578,36 @@ export async function runServerToolOrchestration(options) {
             flowId: engineResult.execution.flowId
         };
     }
+    let shouldInjectStopLoopWarning = false;
+    if (isStopMessageFlow && loopState) {
+        const elapsedMs = typeof loopState.startedAtMs === 'number' && Number.isFinite(loopState.startedAtMs)
+            ? Math.max(0, Date.now() - loopState.startedAtMs)
+            : 0;
+        if (elapsedMs >= STOP_MESSAGE_STAGE_TIMEOUT_MS) {
+            throw createStopMessageFetchFailedError({
+                requestId: options.requestId,
+                reason: 'stage_timeout',
+                elapsedMs,
+                timeoutMs: STOP_MESSAGE_STAGE_TIMEOUT_MS
+            });
+        }
+        const pairRepeatCount = typeof loopState.stopPairRepeatCount === 'number' && Number.isFinite(loopState.stopPairRepeatCount)
+            ? Math.max(0, Math.floor(loopState.stopPairRepeatCount))
+            : 0;
+        if (pairRepeatCount >= STOP_MESSAGE_LOOP_FAIL_THRESHOLD) {
+            throw createStopMessageFetchFailedError({
+                requestId: options.requestId,
+                reason: 'loop_limit',
+                elapsedMs,
+                repeatCount: pairRepeatCount
+            });
+        }
+        if (pairRepeatCount >= STOP_MESSAGE_LOOP_WARN_THRESHOLD && !loopState.stopPairWarned) {
+            loopState.stopPairWarned = true;
+            shouldInjectStopLoopWarning = true;
+            logProgress(2, totalSteps, 'loop warning armed', { flowId });
+        }
+    }
     if (isAdapterClientDisconnected(options.adapterContext)) {
         logProgress(5, totalSteps, 'completed (client disconnected)', { flowId });
         return {
@@ -423,9 +640,9 @@ export async function runServerToolOrchestration(options) {
         (typeof options.entryEndpoint === 'string' && options.entryEndpoint.trim().length
             ? options.entryEndpoint
             : followupEntryEndpoint);
-    // For stateful auto-followups (e.g. stop_message_flow), keep the same providerKey/alias.
-    // Otherwise the followup requestId suffix would cause round-robin alias switching.
-    if (isStopMessageFlow) {
+    // For stateful auto-followups (e.g. stop_message_flow / clock_hold_flow), keep the same providerKey/alias.
+    // Otherwise the followup requestId suffix would cause round-robin alias switching and compatibility drift.
+    if (isStopMessageFlow || isClockHoldFlow) {
         const providerKeyRaw = options.adapterContext.providerKey;
         const providerKey = typeof providerKeyRaw === 'string' && providerKeyRaw.trim().length ? providerKeyRaw.trim() : '';
         if (providerKey) {
@@ -436,6 +653,9 @@ export async function runServerToolOrchestration(options) {
     const maxAttempts = retryEmptyFollowupOnce ? 2 : 1;
     const followupRequestId = buildFollowupRequestId(options.requestId, engineResult.execution.followup.requestIdSuffix);
     let followupPayload = coerceFollowupPayloadStream(followupPayloadRaw, metadata.stream === true);
+    if (shouldInjectStopLoopWarning) {
+        appendStopMessageLoopWarning(followupPayload, loopState?.stopPairRepeatCount ?? STOP_MESSAGE_LOOP_WARN_THRESHOLD);
+    }
     followupPayload = applyHubFollowupPolicyShadow({
         requestId: followupRequestId,
         entryEndpoint: followupEntryEndpoint,
@@ -451,20 +671,45 @@ export async function runServerToolOrchestration(options) {
     // stop_message_flow 的计数器递增由 handler 在决定触发时处理，engine 不再提前递增。
     const stopMessageReservation = null;
     for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        const elapsedBeforeAttempt = isStopMessageFlow && loopState && typeof loopState.startedAtMs === 'number' && Number.isFinite(loopState.startedAtMs)
+            ? Math.max(0, Date.now() - loopState.startedAtMs)
+            : 0;
+        if (isStopMessageFlow && elapsedBeforeAttempt >= STOP_MESSAGE_STAGE_TIMEOUT_MS) {
+            throw createStopMessageFetchFailedError({
+                requestId: options.requestId,
+                reason: 'stage_timeout',
+                elapsedMs: elapsedBeforeAttempt,
+                timeoutMs: STOP_MESSAGE_STAGE_TIMEOUT_MS,
+                attempt,
+                maxAttempts
+            });
+        }
+        const attemptTimeoutMs = isStopMessageFlow && STOP_MESSAGE_STAGE_TIMEOUT_MS > elapsedBeforeAttempt
+            ? Math.max(1, Math.min(followupTimeoutMs, STOP_MESSAGE_STAGE_TIMEOUT_MS - elapsedBeforeAttempt))
+            : followupTimeoutMs;
         try {
             followup = await withTimeout(options.reenterPipeline({
                 entryEndpoint: followupEntryEndpoint,
                 requestId: followupRequestId,
                 body: followupPayload,
                 metadata
-            }), followupTimeoutMs, () => createServerToolTimeoutError({
-                requestId: options.requestId,
-                phase: 'followup',
-                timeoutMs: followupTimeoutMs,
-                flowId: engineResult.execution.flowId,
-                attempt,
-                maxAttempts
-            }));
+            }), attemptTimeoutMs, () => isStopMessageFlow
+                ? createStopMessageFetchFailedError({
+                    requestId: options.requestId,
+                    reason: 'stage_timeout',
+                    elapsedMs: elapsedBeforeAttempt,
+                    timeoutMs: STOP_MESSAGE_STAGE_TIMEOUT_MS,
+                    attempt,
+                    maxAttempts
+                })
+                : createServerToolTimeoutError({
+                    requestId: options.requestId,
+                    phase: 'followup',
+                    timeoutMs: attemptTimeoutMs,
+                    flowId: engineResult.execution.flowId,
+                    attempt,
+                    maxAttempts
+                }));
             // Treat empty followup as failure for auto followup flows:
             // - retry once (maxAttempts=2)
             // - if still empty, surface as HTTP error so client can retry.
@@ -784,7 +1029,7 @@ function resolveRouteHint(adapterContext, flowId) {
     }
     return routeId;
 }
-function buildServerToolLoopState(adapterContext, flowId, payload) {
+function buildServerToolLoopState(adapterContext, flowId, payload, response) {
     if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
         return null;
     }
@@ -800,11 +1045,33 @@ function buildServerToolLoopState(adapterContext, flowId, payload) {
         ? Math.max(0, Math.floor(previous.repeatCount))
         : 0;
     const repeatCount = sameFlow && samePayload ? prevCount + 1 : 1;
-    return {
+    const previousStartedAtMs = sameFlow && previous && typeof previous.startedAtMs === 'number' && Number.isFinite(previous.startedAtMs)
+        ? Math.max(0, Math.floor(previous.startedAtMs))
+        : undefined;
+    const startedAtMs = previousStartedAtMs ?? Date.now();
+    const base = {
         ...(flowId ? { flowId } : {}),
         payloadHash,
-        repeatCount
+        repeatCount,
+        startedAtMs
     };
+    if (flowId === 'stop_message_flow') {
+        const pairHash = hashStopMessageRequestResponsePair(payload, response);
+        if (pairHash) {
+            const previousPairHash = sameFlow && previous && typeof previous.stopPairHash === 'string' ? previous.stopPairHash : undefined;
+            const previousPairCount = sameFlow && previous && typeof previous.stopPairRepeatCount === 'number' && Number.isFinite(previous.stopPairRepeatCount)
+                ? Math.max(0, Math.floor(previous.stopPairRepeatCount))
+                : 0;
+            const stopPairRepeatCount = previousPairHash === pairHash ? previousPairCount + 1 : 1;
+            const stopPairWarned = previousPairHash === pairHash && previous && typeof previous.stopPairWarned === 'boolean'
+                ? previous.stopPairWarned
+                : false;
+            base.stopPairHash = pairHash;
+            base.stopPairRepeatCount = stopPairRepeatCount;
+            base.stopPairWarned = stopPairWarned;
+        }
+    }
+    return base;
 }
 function readServerToolLoopState(adapterContext) {
     if (!adapterContext || typeof adapterContext !== 'object') {
@@ -821,13 +1088,27 @@ function readServerToolLoopState(adapterContext) {
     const repeatCount = typeof record.repeatCount === 'number' && Number.isFinite(record.repeatCount)
         ? Math.max(0, Math.floor(record.repeatCount))
         : undefined;
+    const startedAtMs = typeof record.startedAtMs === 'number' && Number.isFinite(record.startedAtMs)
+        ? Math.max(0, Math.floor(record.startedAtMs))
+        : undefined;
+    const stopPairHash = typeof record.stopPairHash === 'string' && record.stopPairHash.trim().length
+        ? record.stopPairHash.trim()
+        : undefined;
+    const stopPairRepeatCount = typeof record.stopPairRepeatCount === 'number' && Number.isFinite(record.stopPairRepeatCount)
+        ? Math.max(0, Math.floor(record.stopPairRepeatCount))
+        : undefined;
+    const stopPairWarned = typeof record.stopPairWarned === 'boolean' ? record.stopPairWarned : undefined;
     if (!payloadHash) {
         return null;
     }
     return {
         ...(flowId ? { flowId } : {}),
         payloadHash,
-        ...(repeatCount !== undefined ? { repeatCount } : {})
+        ...(repeatCount !== undefined ? { repeatCount } : {}),
+        ...(startedAtMs !== undefined ? { startedAtMs } : {}),
+        ...(stopPairHash ? { stopPairHash } : {}),
+        ...(stopPairRepeatCount !== undefined ? { stopPairRepeatCount } : {}),
+        ...(stopPairWarned !== undefined ? { stopPairWarned } : {})
     };
 }
 function hashPayload(payload) {
@@ -839,6 +1120,71 @@ function hashPayload(payload) {
         return null;
     }
 }
+function hashStopMessageRequestResponsePair(payload, response) {
+    try {
+        const normalizedPayload = sanitizeLoopHashValue(payload);
+        const normalizedResponse = sanitizeLoopHashValue(response ?? {});
+        const stable = stableStringify({ request: normalizedPayload, response: normalizedResponse });
+        return createHash('sha1').update(stable).digest('hex');
+    }
+    catch {
+        return null;
+    }
+}
+function sanitizeLoopHashValue(value) {
+    if (value === null || value === undefined) {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => sanitizeLoopHashValue(entry));
+    }
+    if (typeof value !== 'object') {
+        return value;
+    }
+    const record = value;
+    const normalized = {};
+    const volatileKeys = new Set([
+        'id',
+        'created',
+        'created_at',
+        'timestamp',
+        'request_id',
+        'requestId',
+        'trace_id',
+        'response_id',
+        'system_fingerprint'
+    ]);
+    for (const key of Object.keys(record)) {
+        if (volatileKeys.has(key)) {
+            continue;
+        }
+        normalized[key] = sanitizeLoopHashValue(record[key]);
+    }
+    return normalized;
+}
+function appendStopMessageLoopWarning(payload, repeatCountRaw) {
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        return;
+    }
+    const messages = Array.isArray(payload.messages)
+        ? payload.messages
+        : null;
+    if (!messages) {
+        return;
+    }
+    const repeatCount = Number.isFinite(repeatCountRaw)
+        ? Math.max(STOP_MESSAGE_LOOP_WARN_THRESHOLD, Math.floor(repeatCountRaw))
+        : STOP_MESSAGE_LOOP_WARN_THRESHOLD;
+    const warningText = [
+        `检测到 stopMessage 请求/响应参数已连续 ${repeatCount} 轮一致。`,
+        '请立即尝试跳出循环（换路径、换验证方法、或直接给结论）。',
+        `若继续达到 ${STOP_MESSAGE_LOOP_FAIL_THRESHOLD} 轮一致，将返回 fetch failed 网络错误并停止自动续跑。`
+    ].join('\n');
+    messages.push({
+        role: 'system',
+        content: warningText
+    });
+}
 function stableStringify(value) {
     if (value === null || typeof value !== 'object') {
         return JSON.stringify(value);

package/dist/servertool/handlers/antigravity-thought-signature-bootstrap.js

@@ -57,19 +57,19 @@ function buildClockToolSchema() {
         type: 'function',
         function: {
             name: 'clock',
-            description: 'Time + Alarm for this session. Use get/schedule/list/cancel/clear. Scheduled reminders will be injected into future requests.',
+            description: 'Time + Alarm for this session. Use get/schedule/update/list/cancel/clear. Scheduled reminders will be injected into future requests.',
             strict: true,
             parameters: {
                 type: 'object',
                 properties: {
                     action: {
                         type: 'string',
-                        enum: ['get', 'schedule', 'list', 'cancel', 'clear'],
-                        description: 'Get current time, or schedule/list/cancel/clear session-scoped reminders.'
+                        enum: ['get', 'schedule', 'update', 'list', 'cancel', 'clear'],
+                        description: 'Get current time, or schedule/update/list/cancel/clear session-scoped reminders.'
                     },
                     items: {
                         type: 'array',
-                        description: 'For schedule: list of reminders to add.',
+                        description: 'For schedule/update: list of reminders (update uses items[0]).',
                         items: {
                             type: 'object',
                             properties: {
@@ -96,7 +96,7 @@ function buildClockToolSchema() {
                     },
                     taskId: {
                         type: 'string',
-                        description: 'For cancel: taskId to remove.'
+                        description: 'For cancel/update: taskId to target.'
                     }
                 },
                 required: ['action', 'items', 'taskId'],
@@ -198,4 +198,4 @@ const handler = async (ctx) => {
         })
     };
 };
-registerServerToolHandler(FLOW_ID, handler, { trigger: 'auto' });
+registerServerToolHandler(FLOW_ID, handler, { trigger: 'auto', hook: { phase: 'default', priority: 30 } });