@jsonstudio/llms 0.6.1739 → 0.6.1890

package/dist/servertool/handlers/stop-message-auto.js

@@ -1,8 +1,11 @@
 import { registerServerToolHandler } from '../registry.js';
-import { loadRoutingInstructionStateSync, saveRoutingInstructionStateAsync } from '../../router/virtual-router/sticky-session-store.js';
+import { loadRoutingInstructionStateSync, saveRoutingInstructionStateAsync, saveRoutingInstructionStateSync } from '../../router/virtual-router/sticky-session-store.js';
 import { isCompactionRequest } from './compaction-detect.js';
 import { extractCapturedChatSeed } from './followup-request-builder.js';
+import { resolveStopMessageStageDecision } from './stop-message-stage-policy.js';
 import { readRuntimeMetadata } from '../../conversion/shared/runtime-metadata.js';
+import { isStopEligibleForServerTool } from '../stop-gateway-context.js';
+import { attachStopMessageCompareContext } from '../stop-message-compare-context.js';
 const STOPMESSAGE_DEBUG = (process.env.ROUTECODEX_STOPMESSAGE_DEBUG || '').trim() === '1';
 const STOPMESSAGE_IMPLICIT_GEMINI = (process.env.ROUTECODEX_STOPMESSAGE_IMPLICIT_GEMINI || '').trim() === '1';
 function debugLog(message, extra) {
@@ -20,190 +23,277 @@ function debugLog(message, extra) {
     }
 }
 const FLOW_ID = 'stop_message_flow';
+const STOP_MESSAGE_EXECUTION_DIRECTIVE = [
+    '执行策略（必须遵守）：',
+    '- 禁止输出口播式状态汇报（如“继续执行中”“我会继续”）。',
+    '- 先执行一个真实动作（优先工具调用），再在必要时简短汇报结果。',
+    '- 如果即将返回 finish_reason=stop 或协议等价 end_turn，先调用 continue_execution 工具，不要直接结束会话。'
+].join('\n');
 const handler = async (ctx) => {
     const record = ctx.adapterContext;
     const rt = readRuntimeMetadata(ctx.adapterContext);
+    const compare = {
+        armed: false,
+        mode: 'off',
+        allowModeOnly: false,
+        textLength: 0,
+        maxRepeats: 0,
+        used: 0,
+        remaining: 0,
+        active: false,
+        stopEligible: false,
+        hasCapturedRequest: false,
+        compactionRequest: false,
+        hasSeed: false,
+        decision: 'skip',
+        reason: 'handler_start'
+    };
+    const syncCompareRound = () => {
+        const max = Number.isFinite(compare.maxRepeats) ? Math.max(0, Math.floor(compare.maxRepeats)) : 0;
+        const used = Number.isFinite(compare.used) ? Math.max(0, Math.floor(compare.used)) : 0;
+        compare.maxRepeats = max;
+        compare.used = used;
+        compare.remaining = max > 0 ? Math.max(0, max - used) : 0;
+        compare.active =
+            compare.armed &&
+                compare.mode !== 'off' &&
+                max > 0 &&
+                (compare.textLength > 0 || compare.allowModeOnly);
+    };
+    const updateCompare = (patch) => {
+        Object.assign(compare, patch);
+        syncCompareRound();
+    };
+    const markSkip = (reason, patch) => {
+        updateCompare({
+            decision: 'skip',
+            reason,
+            ...(patch || {})
+        });
+        return null;
+    };
     debugLog('handler_start', {
         requestId: record.requestId,
         providerProtocol: record.providerProtocol
     });
-    const followupFlagRaw = rt?.serverToolFollowup;
-    if (followupFlagRaw === true ||
-        (typeof followupFlagRaw === 'string' && followupFlagRaw.trim().toLowerCase() === 'true')) {
-        // Allow chained followups only within the stop_message_flow loop itself.
-        // Other servertool followups must not re-trigger stopMessage (prevents cross-flow loops).
-        const loopState = rt?.serverToolLoopState;
-        const flowId = loopState && typeof loopState === 'object' && !Array.isArray(loopState)
-            ? String(loopState.flowId || '').trim()
-            : '';
-        if (flowId !== FLOW_ID) {
+    try {
+        const followupFlagRaw = rt?.serverToolFollowup;
+        if (followupFlagRaw === true ||
+            (typeof followupFlagRaw === 'string' && followupFlagRaw.trim().toLowerCase() === 'true')) {
             debugLog('skip_followup_loop');
-            return null;
+            return markSkip('skip_followup_loop');
         }
-    }
-    if (hasCompactionFlag(rt)) {
-        debugLog('skip_compaction_flag');
-        return null;
-    }
-    const connectionState = resolveClientConnectionState(record.clientConnectionState);
-    if (connectionState?.disconnected === true) {
-        debugLog('skip_client_disconnected');
-        return null;
-    }
-    const clientDisconnectedRaw = record.clientDisconnected;
-    if (clientDisconnectedRaw === true ||
-        (typeof clientDisconnectedRaw === 'string' && clientDisconnectedRaw.trim().toLowerCase() === 'true')) {
-        debugLog('skip_client_disconnected_flag');
-        return null;
-    }
-    const stickyKey = resolveStickyKey(record);
-    if (!stickyKey) {
-        debugLog('skip_no_sticky_key');
-        return null;
-    }
-    let state = loadRoutingInstructionStateSync(stickyKey);
-    // If stopMessage was created implicitly (auto) but implicit mode is disabled, do not run it.
-    // This avoids surprising followups like "继续执行" when the user never enabled stopMessage.
-    if (state &&
-        typeof state.stopMessageSource === 'string' &&
-        state.stopMessageSource.trim().toLowerCase() === 'auto' &&
-        !STOPMESSAGE_IMPLICIT_GEMINI) {
-        state.stopMessageText = undefined;
-        state.stopMessageMaxRepeats = undefined;
-        state.stopMessageUsed = undefined;
-        state.stopMessageUpdatedAt = undefined;
-        state.stopMessageLastUsedAt = undefined;
-        saveRoutingInstructionStateAsync(stickyKey, state);
-        debugLog('skip_auto_state_disabled', { stickyKey });
-        return null;
-    }
-    if (!state || !state.stopMessageText || !state.stopMessageMaxRepeats) {
-        const fallback = resolveStopMessageSnapshot(rt?.stopMessageState);
-        if (fallback) {
-            state = createStopMessageState(fallback);
+        if (hasCompactionFlag(rt)) {
+            debugLog('skip_compaction_flag');
+            return markSkip('skip_compaction_flag');
+        }
+        const connectionState = resolveClientConnectionState(record.clientConnectionState);
+        if (connectionState?.disconnected === true) {
+            debugLog('skip_client_disconnected');
+            return markSkip('skip_client_disconnected');
+        }
+        const clientDisconnectedRaw = record.clientDisconnected;
+        if (clientDisconnectedRaw === true ||
+            (typeof clientDisconnectedRaw === 'string' && clientDisconnectedRaw.trim().toLowerCase() === 'true')) {
+            debugLog('skip_client_disconnected_flag');
+            return markSkip('skip_client_disconnected_flag');
         }
-        else {
-            const implicit = STOPMESSAGE_IMPLICIT_GEMINI ? resolveImplicitGeminiStopMessageSnapshot(ctx, record) : null;
-            if (!implicit) {
-                debugLog('skip_no_state', { stickyKey });
-                return null;
+        const stickyKey = resolveStickyKey(record, rt);
+        let state = stickyKey ? loadRoutingInstructionStateSync(stickyKey) : undefined;
+        if (state &&
+            typeof state.stopMessageSource === 'string' &&
+            state.stopMessageSource.trim().toLowerCase() === 'auto' &&
+            !STOPMESSAGE_IMPLICIT_GEMINI) {
+            clearStopMessageState(state, Date.now());
+            if (stickyKey) {
+                persistStopMessageState(stickyKey, state);
             }
-            state = createStopMessageState(implicit);
+            debugLog('skip_auto_state_disabled', { stickyKey });
+            return markSkip('skip_auto_state_disabled', { armed: false, mode: 'off' });
         }
-        saveRoutingInstructionStateAsync(stickyKey, state);
-    }
-    const text = typeof state.stopMessageText === 'string' ? state.stopMessageText.trim() : '';
-    const maxRepeats = typeof state.stopMessageMaxRepeats === 'number' && Number.isFinite(state.stopMessageMaxRepeats)
-        ? Math.max(1, Math.floor(state.stopMessageMaxRepeats))
-        : 0;
-    if (!text || maxRepeats <= 0) {
-        debugLog('skip_invalid_text_or_maxRepeats', {
-            stickyKey,
+        if (!state || !hasArmedStopMessageState(state)) {
+            const fallback = resolveStopMessageSnapshot(rt?.stopMessageState);
+            if (fallback) {
+                state = createStopMessageState(fallback);
+            }
+            else {
+                const implicit = STOPMESSAGE_IMPLICIT_GEMINI ? resolveImplicitGeminiStopMessageSnapshot(ctx, record) : null;
+                if (!implicit) {
+                    debugLog('skip_no_state', { stickyKey });
+                    return markSkip('skip_no_state', { armed: false, mode: 'off' });
+                }
+                state = createStopMessageState(implicit);
+            }
+            if (stickyKey) {
+                persistStopMessageState(stickyKey, state);
+            }
+        }
+        updateCompare({ armed: hasArmedStopMessageState(state) });
+        const text = typeof state.stopMessageText === 'string' ? state.stopMessageText.trim() : '';
+        const maxRepeats = typeof state.stopMessageMaxRepeats === 'number' && Number.isFinite(state.stopMessageMaxRepeats)
+            ? Math.max(1, Math.floor(state.stopMessageMaxRepeats))
+            : 0;
+        const stageMode = normalizeStopMessageModeValue(state.stopMessageStageMode);
+        const mode = stageMode === 'on' || stageMode === 'auto' || stageMode === 'off' ? stageMode : 'off';
+        const allowModeOnlyState = !text && maxRepeats > 0 && (stageMode === 'on' || stageMode === 'auto');
+        updateCompare({
+            mode,
+            allowModeOnly: allowModeOnlyState,
             textLength: text.length,
             maxRepeats
         });
-        return null;
-    }
-    const used = typeof state.stopMessageUsed === 'number' && Number.isFinite(state.stopMessageUsed)
-        ? Math.max(0, Math.floor(state.stopMessageUsed))
-        : 0;
-    if (used >= maxRepeats) {
-        debugLog('skip_reached_max_repeats', {
-            stickyKey,
-            used,
-            maxRepeats
+        if ((!text && !allowModeOnlyState) || maxRepeats <= 0) {
+            debugLog('skip_invalid_text_or_maxRepeats', {
+                stickyKey,
+                textLength: text.length,
+                maxRepeats,
+                stageMode
+            });
+            return markSkip('skip_invalid_text_or_maxRepeats');
+        }
+        const used = typeof state.stopMessageUsed === 'number' && Number.isFinite(state.stopMessageUsed)
+            ? Math.max(0, Math.floor(state.stopMessageUsed))
+            : 0;
+        updateCompare({ used });
+        if (used >= maxRepeats) {
+            debugLog('skip_reached_max_repeats', {
+                stickyKey,
+                used,
+                maxRepeats
+            });
+            clearStopMessageState(state, Date.now());
+            if (stickyKey) {
+                persistStopMessageState(stickyKey, state);
+            }
+            return markSkip('skip_reached_max_repeats');
+        }
+        const stopEligible = isStopEligibleForServerTool(ctx.base, ctx.adapterContext);
+        updateCompare({ stopEligible });
+        if (!stopEligible) {
+            debugLog('skip_not_stop_finish_reason', {
+                stickyKey
+            });
+            return markSkip('skip_not_stop_finish_reason');
+        }
+        const captured = getCapturedRequest(ctx.adapterContext);
+        updateCompare({ hasCapturedRequest: Boolean(captured) });
+        if (!captured) {
+            debugLog('skip_no_captured_request', {
+                stickyKey
+            });
+            return markSkip('skip_no_captured_request');
+        }
+        const compactionRequest = isCompactionRequest(captured);
+        updateCompare({ compactionRequest });
+        if (compactionRequest) {
+            debugLog('skip_compaction_request', { stickyKey });
+            return markSkip('skip_compaction_request');
+        }
+        const entryEndpoint = resolveEntryEndpoint(record);
+        const seed = extractCapturedChatSeed(captured);
+        updateCompare({ hasSeed: Boolean(seed) });
+        if (!seed) {
+            debugLog('skip_failed_build_followup', { stickyKey });
+            return markSkip('skip_failed_build_followup');
+        }
+        const stageDecision = resolveStopMessageStageDecision({
+            baseText: text,
+            state,
+            capturedMessages: Array.isArray(seed.messages)
+                ? (seed.messages || [])
+                : []
         });
-        // Auto-clear after reaching max repeats to avoid leaving an "exhausted" stopMessage stuck in sticky state.
-        const now = Date.now();
-        state.stopMessageText = undefined;
-        state.stopMessageMaxRepeats = undefined;
-        state.stopMessageUsed = undefined;
-        state.stopMessageSource = undefined;
-        // Keep monotonic timestamps as a tombstone to prevent accidental re-application from replayed history.
-        state.stopMessageUpdatedAt = now;
-        state.stopMessageLastUsedAt = now;
-        saveRoutingInstructionStateAsync(stickyKey, state);
-        return null;
-    }
-    if (!isStopFinishReason(ctx.base)) {
-        debugLog('skip_not_stop_finish_reason', {
-            stickyKey
+        state.stopMessageObservationHash = stageDecision.observationHash;
+        state.stopMessageObservationStableCount = stageDecision.observationStableCount;
+        state.stopMessageBdWorkState = stageDecision.bdWorkState;
+        state.stopMessageStage = stageDecision.stage;
+        updateCompare({
+            stage: stageDecision.stage,
+            bdWorkState: stageDecision.bdWorkState,
+            observationHash: stageDecision.observationHash,
+            observationStableCount: stageDecision.observationStableCount,
+            toolSignatureHash: stageDecision.toolSignatureHash
         });
-        return null;
-    }
-    const captured = getCapturedRequest(ctx.adapterContext);
-    if (!captured) {
-        debugLog('skip_no_captured_request', {
-            stickyKey
+        if (stageDecision.action === 'stop') {
+            clearStopMessageState(state, Date.now());
+            if (stickyKey) {
+                persistStopMessageState(stickyKey, state);
+            }
+            debugLog('stop_by_stage_policy', {
+                stickyKey,
+                reason: stageDecision.stopReason,
+                observationStableCount: stageDecision.observationStableCount,
+                bdWorkState: stageDecision.bdWorkState
+            });
+            return markSkip('stage_policy_stop');
+        }
+        const followupText = typeof stageDecision.followupText === 'string' && stageDecision.followupText.trim()
+            ? stageDecision.followupText.trim()
+            : text;
+        if (!followupText) {
+            debugLog('skip_empty_followup_text_after_stage', {
+                stickyKey,
+                stage: stageDecision.stage,
+                bdWorkState: stageDecision.bdWorkState
+            });
+            return markSkip('skip_empty_followup_text_after_stage');
+        }
+        const nextUsed = used + 1;
+        state.stopMessageUsed = nextUsed;
+        state.stopMessageLastUsedAt = Date.now();
+        updateCompare({ used: nextUsed });
+        if (nextUsed >= maxRepeats) {
+            clearStopMessageState(state, Date.now());
+        }
+        if (stickyKey) {
+            persistStopMessageState(stickyKey, state);
+        }
+        const followupProviderKey = resolveStopMessageFollowupProviderKey({ record, runtimeMetadata: rt });
+        const followupToolContentMaxChars = resolveStopMessageFollowupToolContentMaxChars({
+            providerKey: followupProviderKey,
+            model: seed.model
         });
-        return null;
-    }
-    if (isCompactionRequest(captured)) {
-        debugLog('skip_compaction_request', { stickyKey });
-        return null;
-    }
-    const entryEndpoint = resolveEntryEndpoint(record);
-    const seed = extractCapturedChatSeed(captured);
-    if (!seed) {
-        debugLog('skip_failed_build_followup', { stickyKey });
-        return null;
+        const followupOps = [];
+        if (typeof followupToolContentMaxChars === 'number' &&
+            Number.isFinite(followupToolContentMaxChars) &&
+            followupToolContentMaxChars > 0) {
+            followupOps.push({ op: 'compact_tool_content', maxChars: Math.floor(followupToolContentMaxChars) });
+        }
+        followupOps.push({ op: 'ensure_standard_tools' });
+        followupOps.push({ op: 'inject_system_text', text: STOP_MESSAGE_EXECUTION_DIRECTIVE });
+        followupOps.push({ op: 'append_user_text', text: followupText });
+        updateCompare({
+            decision: 'trigger',
+            reason: 'triggered'
+        });
+        return {
+            flowId: FLOW_ID,
+            finalize: async () => ({
+                chatResponse: ctx.base,
+                execution: {
+                    flowId: FLOW_ID,
+                    followup: {
+                        requestIdSuffix: ':stop_followup',
+                        entryEndpoint,
+                        injection: {
+                            ops: followupOps
+                        },
+                        metadata: (connectionState ? { clientConnectionState: connectionState } : {})
+                    }
+                }
+            })
+        };
     }
-    // Extract assistant message for potential followup injection (no-op today; keeps compat).
-    void extractAssistantMessageForFollowup(ctx.base);
-    // Increment stopMessage usage counter when we decide to trigger followup.
-    const nextUsed = used + 1;
-    state.stopMessageUsed = nextUsed;
-    state.stopMessageLastUsedAt = Date.now();
-    // If this will be the last allowed trigger, mark it for cleanup.
-    // We still return the followup plan for this trigger, but clear the config
-    // so the next response won't trigger again.
-    if (nextUsed >= maxRepeats) {
-        const now = Date.now();
-        state.stopMessageText = undefined;
-        state.stopMessageMaxRepeats = undefined;
-        state.stopMessageUsed = undefined;
-        state.stopMessageSource = undefined;
-        state.stopMessageUpdatedAt = now;
+    finally {
+        attachStopMessageCompareContext(ctx.adapterContext, compare);
     }
-    saveRoutingInstructionStateAsync(stickyKey, state);
-    const followupProviderKey = resolveStopMessageFollowupProviderKey({ record, runtimeMetadata: rt });
-    const followupToolContentMaxChars = resolveStopMessageFollowupToolContentMaxChars({
-        providerKey: followupProviderKey,
-        model: seed.model
-    });
-    const followupOps = [];
-    if (typeof followupToolContentMaxChars === 'number' &&
-        Number.isFinite(followupToolContentMaxChars) &&
-        followupToolContentMaxChars > 0) {
-        followupOps.push({ op: 'compact_tool_content', maxChars: Math.floor(followupToolContentMaxChars) });
-    }
-    followupOps.push({ op: 'append_assistant_message', required: false });
-    followupOps.push({ op: 'ensure_standard_tools' });
-    followupOps.push({ op: 'append_user_text', text });
-    return {
-        flowId: FLOW_ID,
-        finalize: async () => ({
-            chatResponse: ctx.base,
-            execution: {
-                flowId: FLOW_ID,
-                followup: {
-                    requestIdSuffix: ':stop_followup',
-                    entryEndpoint,
-                    injection: {
-                        ops: followupOps
-                    },
-                    metadata: (connectionState ? { clientConnectionState: connectionState } : {})
-                }
-            }
-        })
-    };
 };
-registerServerToolHandler('stop_message_auto', handler, { trigger: 'auto' });
-function resolveStickyKey(record) {
-    const sessionId = typeof record.sessionId === 'string' && record.sessionId.trim() ? record.sessionId.trim() : '';
-    const conversationId = typeof record.conversationId === 'string' && record.conversationId.trim()
-        ? record.conversationId.trim()
-        : '';
+registerServerToolHandler('stop_message_auto', handler, { trigger: 'auto', hook: { phase: 'default', priority: 40 } });
+function resolveStickyKey(record, runtimeMetadata) {
+    const sessionId = readSessionScopeValue(record, runtimeMetadata, 'sessionId') ||
+        readSessionScopeValue(record, runtimeMetadata, 'session_id');
+    const conversationId = readSessionScopeValue(record, runtimeMetadata, 'conversationId') ||
+        readSessionScopeValue(record, runtimeMetadata, 'conversation_id');
     if (sessionId) {
         return `session:${sessionId}`;
     }
@@ -212,6 +302,47 @@ function resolveStickyKey(record) {
     }
     return undefined;
 }
+function persistStopMessageState(stickyKey, state) {
+    if (!stickyKey) {
+        return;
+    }
+    saveRoutingInstructionStateSync(stickyKey, state);
+    saveRoutingInstructionStateAsync(stickyKey, state);
+}
+function readSessionScopeValue(record, runtimeMetadata, key) {
+    const direct = toNonEmptyText(record[key]);
+    if (direct) {
+        return direct;
+    }
+    const metadata = asRecord(record.metadata);
+    const fromMetadata = metadata ? toNonEmptyText(metadata[key]) : '';
+    if (fromMetadata) {
+        return fromMetadata;
+    }
+    const fromMetadataContext = metadata ? toNonEmptyText(asRecord(metadata.context)?.[key]) : '';
+    if (fromMetadataContext) {
+        return fromMetadataContext;
+    }
+    const originalRequest = asRecord(record.originalRequest);
+    const fromOriginalMetadata = originalRequest
+        ? toNonEmptyText(asRecord(originalRequest.metadata)?.[key])
+        : '';
+    if (fromOriginalMetadata) {
+        return fromOriginalMetadata;
+    }
+    const runtime = asRecord(runtimeMetadata);
+    const fromRuntime = runtime ? toNonEmptyText(runtime[key]) : '';
+    if (fromRuntime) {
+        return fromRuntime;
+    }
+    return '';
+}
+function asRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}
 function toNonEmptyText(value) {
     return typeof value === 'string' && value.trim().length ? value.trim() : '';
 }
@@ -233,6 +364,30 @@ function readProviderKeyFromMetadata(value) {
     }
     return '';
 }
+function hasArmedStopMessageState(state) {
+    const maxRepeats = typeof state.stopMessageMaxRepeats === 'number' && Number.isFinite(state.stopMessageMaxRepeats)
+        ? Math.max(1, Math.floor(state.stopMessageMaxRepeats))
+        : 0;
+    if (maxRepeats <= 0) {
+        return false;
+    }
+    const text = typeof state.stopMessageText === 'string' ? state.stopMessageText.trim() : '';
+    if (text) {
+        return true;
+    }
+    const mode = normalizeStopMessageModeValue(state.stopMessageStageMode);
+    return mode === 'on' || mode === 'auto';
+}
+function normalizeStopMessageModeValue(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'on' || normalized === 'off' || normalized === 'auto') {
+        return normalized;
+    }
+    return undefined;
+}
 function resolveStopMessageFollowupProviderKey(args) {
     const direct = toNonEmptyText(args.record.providerKey) ||
         toNonEmptyText(args.record.providerId) ||
@@ -259,100 +414,27 @@ function resolveStopMessageFollowupToolContentMaxChars(params) {
     }
     return undefined;
 }
-function isStopFinishReason(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()
-            : '';
-        // 将模型视为“自然结束”的场景：
-        // - OpenAI 兼容：finish_reason === 'stop'
-        // - 截断场景：finish_reason === 'length'（例如 Gemini/Claude 流式输出被 max token 截断）
-        // 统一视作可触发 stopMessage 的终止点；仅排除显式的 tool_calls。
-        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) {
-            // 如果当前响应仍在发起工具调用，则由工具执行驱动后续轮次，不触发 stopMessage。
-            return false;
-        }
-        return true;
-    }
-    // OpenAI Responses shape: status completed + no required_action + no tool-like output entries
-    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;
-    }
-    const outputRaw = Array.isArray(payload.output) ? payload.output : [];
-    if (!outputRaw.length) {
-        return false;
-    }
-    if (outputRaw.some((item) => hasToolLikeOutput(item))) {
-        return false;
-    }
-    return true;
-}
-function extractAssistantMessageForFollowup(chatResponse) {
-    if (!chatResponse || typeof chatResponse !== 'object' || Array.isArray(chatResponse)) {
-        return null;
-    }
-    const choices = Array.isArray(chatResponse.choices)
-        ? chatResponse.choices
-        : [];
-    if (!choices.length) {
-        return null;
-    }
-    const first = choices[0];
-    if (!first || typeof first !== 'object' || Array.isArray(first)) {
-        return null;
-    }
-    const message = first.message;
-    if (!message || typeof message !== 'object' || Array.isArray(message)) {
-        return null;
-    }
-    const role = typeof message.role === 'string' ? String(message.role) : '';
-    if (role && role.toLowerCase() !== 'assistant') {
-        return null;
-    }
-    const content = message.content;
-    if (typeof content !== 'string' || !content.trim()) {
-        return null;
-    }
-    return { role: 'assistant', content: content.trim() };
-}
 function getCapturedRequest(adapterContext) {
     if (!adapterContext || typeof adapterContext !== 'object') {
         return null;
     }
-    const captured = adapterContext.capturedChatRequest;
-    if (!captured || typeof captured !== 'object' || Array.isArray(captured)) {
-        return null;
+    const contextRecord = adapterContext;
+    const direct = contextRecord.capturedChatRequest;
+    if (direct && typeof direct === 'object' && !Array.isArray(direct)) {
+        return direct;
+    }
+    const runtime = readRuntimeMetadata(contextRecord);
+    const runtimeCaptured = runtime && typeof runtime === 'object' && !Array.isArray(runtime)
+        ? runtime.capturedChatRequest
+        : undefined;
+    if (runtimeCaptured && typeof runtimeCaptured === 'object' && !Array.isArray(runtimeCaptured)) {
+        return runtimeCaptured;
     }
-    return captured;
+    const originalRequest = contextRecord.originalRequest;
+    if (originalRequest && typeof originalRequest === 'object' && !Array.isArray(originalRequest)) {
+        return originalRequest;
+    }
+    return null;
 }
 function extractResponsesOutputText(base) {
     const raw = base.output_text;
@@ -422,7 +504,9 @@ function resolveStopMessageSnapshot(raw) {
     const maxRepeats = typeof record.stopMessageMaxRepeats === 'number' && Number.isFinite(record.stopMessageMaxRepeats)
         ? Math.max(1, Math.floor(record.stopMessageMaxRepeats))
         : 0;
-    if (!text || maxRepeats <= 0) {
+    const stageMode = normalizeStopMessageStageMode(record.stopMessageStageMode);
+    const allowModeOnlyState = !text && maxRepeats > 0 && (stageMode === 'on' || stageMode === 'auto');
+    if ((!text && !allowModeOnlyState) || maxRepeats <= 0) {
         return null;
     }
     const used = typeof record.stopMessageUsed === 'number' && Number.isFinite(record.stopMessageUsed)
@@ -437,13 +521,30 @@ function resolveStopMessageSnapshot(raw) {
     const source = typeof record.stopMessageSource === 'string' && record.stopMessageSource.trim()
         ? record.stopMessageSource.trim()
         : undefined;
+    const stage = typeof record.stopMessageStage === 'string' && record.stopMessageStage.trim()
+        ? record.stopMessageStage.trim()
+        : undefined;
+    const observationHash = typeof record.stopMessageObservationHash === 'string' && record.stopMessageObservationHash.trim()
+        ? record.stopMessageObservationHash.trim()
+        : undefined;
+    const observationStableCount = typeof record.stopMessageObservationStableCount === 'number' && Number.isFinite(record.stopMessageObservationStableCount)
+        ? Math.max(0, Math.floor(record.stopMessageObservationStableCount))
+        : undefined;
+    const bdWorkState = typeof record.stopMessageBdWorkState === 'string' && record.stopMessageBdWorkState.trim()
+        ? record.stopMessageBdWorkState.trim()
+        : undefined;
     return {
         text,
         maxRepeats,
         used,
         ...(source ? { source } : {}),
         ...(updatedAt ? { updatedAt } : {}),
-        ...(lastUsedAt ? { lastUsedAt } : {})
+        ...(lastUsedAt ? { lastUsedAt } : {}),
+        ...(stage ? { stage } : {}),
+        ...(stageMode ? { stageMode } : {}),
+        ...(observationHash ? { observationHash } : {}),
+        ...(typeof observationStableCount === 'number' ? { observationStableCount } : {}),
+        ...(bdWorkState ? { bdWorkState } : {})
     };
 }
 function hasCompactionFlag(rt) {
@@ -478,7 +579,7 @@ function resolveImplicitGeminiStopMessageSnapshot(ctx, record) {
             return null;
         }
         // 仅在本轮响应被视为“自然结束”（stop/length，且无 tool_calls）时触发，避免干扰正常对话。
-        if (!isStopFinishReason(ctx.base)) {
+        if (!isStopEligibleForServerTool(ctx.base, ctx.adapterContext)) {
             return null;
         }
         // 仅在“空回复”时触发隐式 stopMessage：
@@ -564,9 +665,37 @@ function createStopMessageState(snapshot) {
         stopMessageMaxRepeats: snapshot.maxRepeats,
         stopMessageUsed: snapshot.used,
         stopMessageUpdatedAt: snapshot.updatedAt,
-        stopMessageLastUsedAt: snapshot.lastUsedAt
+        stopMessageLastUsedAt: snapshot.lastUsedAt,
+        stopMessageStage: snapshot.stage,
+        stopMessageStageMode: snapshot.stageMode,
+        stopMessageObservationHash: snapshot.observationHash,
+        stopMessageObservationStableCount: snapshot.observationStableCount,
+        stopMessageBdWorkState: snapshot.bdWorkState
     };
 }
+function normalizeStopMessageStageMode(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'on' || normalized === 'off' || normalized === 'auto') {
+        return normalized;
+    }
+    return undefined;
+}
+function clearStopMessageState(state, now) {
+    state.stopMessageText = undefined;
+    state.stopMessageMaxRepeats = undefined;
+    state.stopMessageUsed = undefined;
+    state.stopMessageSource = undefined;
+    state.stopMessageStage = undefined;
+    state.stopMessageStageMode = undefined;
+    state.stopMessageObservationHash = undefined;
+    state.stopMessageObservationStableCount = undefined;
+    state.stopMessageBdWorkState = undefined;
+    state.stopMessageUpdatedAt = now;
+    state.stopMessageLastUsedAt = now;
+}
 function resolveEntryEndpoint(record) {
     const raw = typeof record.entryEndpoint === 'string' && record.entryEndpoint.trim()
         ? record.entryEndpoint.trim()