@jsonstudio/llms 0.6.2172 → 0.6.2979

package/dist/router/virtual-router/features.js

@@ -1,5 +1,5 @@
 import { analyzeMediaAttachments, detectExtendedThinkingKeyword, detectKeyword, extractMessageText, getLatestMessageRole, } from './message-utils.js';
-import { extractAntigravityGeminiSessionId } from '../../conversion/compat/antigravity-session-signature.js';
+import { extractAntigravityGeminiSessionIdWithNative } from './engine-selection/native-router-hotpath.js';
 import { detectCodingTool, detectLastAssistantToolCategory, detectVisionTool, detectWebSearchToolDeclared, 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'];
@@ -12,7 +12,7 @@ export function buildRoutingFeatures(request, metadata) {
                 const text = msg ? extractMessageText(msg) : '';
                 return { role, parts: [{ text }] };
             });
-            return extractAntigravityGeminiSessionId({ contents });
+            return extractAntigravityGeminiSessionIdWithNative({ contents });
         }
         catch {
             return undefined;

package/dist/router/virtual-router/routing-instructions.d.ts

@@ -10,6 +10,8 @@ export interface RoutingInstruction {
     stopMessageText?: string;
     stopMessageMaxRepeats?: number;
     stopMessageStageMode?: 'on' | 'off' | 'auto';
+    stopMessageAiMode?: 'on' | 'off';
+    stopMessageSource?: string;
     /**
      * True when the instruction is parsed from an older user message
      * (not the latest user turn in current request).
@@ -57,14 +59,10 @@ export interface RoutingInstructionState {
     stopMessageUsed?: number;
     stopMessageUpdatedAt?: number;
     stopMessageLastUsedAt?: number;
-    stopMessageStage?: string;
     stopMessageStageMode?: 'on' | 'off' | 'auto';
-    stopMessageObservationHash?: string;
-    stopMessageObservationStableCount?: number;
-    stopMessageBdWorkState?: string;
-    stopMessageAssignedIssueId?: string;
-    stopMessageAssignedIssueSource?: 'in_progress' | 'ready' | 'open';
-    stopMessageNoTaskSummaryUsed?: boolean;
+    stopMessageAiMode?: 'on' | 'off';
+    stopMessageAiSeedPrompt?: string;
+    stopMessageAiHistory?: Array<Record<string, unknown>>;
     preCommandSource?: string;
     preCommandScriptPath?: string;
     preCommandUpdatedAt?: number;

package/dist/router/virtual-router/routing-instructions.js

@@ -5,41 +5,24 @@ import { parsePreCommandInstruction } from './routing-pre-command-parser.js';
 import { applyPreCommandInstructionToState, clearPreCommandState } from './routing-pre-command-actions.js';
 import { deserializeStopMessageState, serializeStopMessageState } from './routing-stop-message-state-codec.js';
 import { deserializePreCommandState, serializePreCommandState } from './routing-pre-command-state-codec.js';
+const ROUTING_INSTRUCTION_MARKER_PATTERN = /<\*\*[\s\S]*?\*\*>/;
+const ROUTING_INSTRUCTION_MARKER_GLOBAL_PATTERN = /<\*\*[\s\S]*?\*\*>/g;
 export function parseRoutingInstructions(messages) {
     const instructions = [];
-    // 从最新一条携带路由指令标记（<** ... **>）的 user 消息中解析指令，
-    // 而不是简单地取"最后一条 user 消息"。这样可以在服务重启后，通过完整
-    // 会话历史恢复 sticky/黑名单状态，同时保持"最后一次指令生效"的语义。
-    let sanitized = null;
-    let sanitizedIndex = -1;
-    let lastUserIndex = -1;
-    for (let idx = messages.length - 1; idx >= 0; idx -= 1) {
-        const message = messages[idx];
-        if (!message || message.role !== 'user') {
-            continue;
-        }
-        if (lastUserIndex < 0) {
-            lastUserIndex = idx;
-        }
-        const content = extractMessageText(message);
-        if (!content) {
-            continue;
-        }
-        const candidate = stripCodeSegments(content);
-        if (!candidate) {
-            continue;
-        }
-        if (!/<\*\*[^*]+\*\*>/.test(candidate)) {
-            continue;
-        }
-        sanitized = candidate;
-        sanitizedIndex = idx;
-        break;
+    // 只解析“当前最新一条消息”中的 marker，避免历史 user marker 在后续轮次被重复回放。
+    const latestMessage = messages.length > 0 ? messages[messages.length - 1] : undefined;
+    if (!latestMessage || latestMessage.role !== 'user') {
+        return instructions;
+    }
+    const content = extractMessageText(latestMessage);
+    if (!content) {
+        return instructions;
     }
-    if (!sanitized) {
+    const sanitized = stripCodeSegments(content);
+    if (!sanitized || !ROUTING_INSTRUCTION_MARKER_PATTERN.test(sanitized)) {
         return instructions;
     }
-    const regex = /<\*\*([^*]+)\*\*>/g;
+    const regex = /<\*\*([\s\S]*?)\*\*>/g;
     let match;
     while ((match = regex.exec(sanitized)) !== null) {
         const instruction = match[1].trim();
@@ -50,27 +33,11 @@ export function parseRoutingInstructions(messages) {
         for (const segment of segments) {
             const parsed = parseSingleInstruction(segment);
             if (parsed) {
-                const fromHistoricalUserMessage = lastUserIndex >= 0 &&
-                    sanitizedIndex >= 0 &&
-                    sanitizedIndex !== lastUserIndex;
-                const normalizedParsed = fromHistoricalUserMessage &&
-                    (parsed.type === 'stopMessageSet' ||
-                        parsed.type === 'stopMessageMode' ||
-                        parsed.type === 'stopMessageClear')
-                    ? { ...parsed, fromHistoricalUserMessage: true }
-                    : parsed;
-                // preCommand 是强副作用命令（执行本地脚本），仅允许从 latest user message 生效。
-                if ((normalizedParsed.type === 'preCommandSet' || normalizedParsed.type === 'preCommandClear') &&
-                    lastUserIndex >= 0 &&
-                    sanitizedIndex >= 0 &&
-                    sanitizedIndex !== lastUserIndex) {
-                    continue;
-                }
-                instructions.push(normalizedParsed);
+                instructions.push(parsed);
             }
         }
     }
-    return instructions;
+    return normalizeStopMessageInstructionPrecedence(instructions);
 }
 /**
  * 解析并预处理路由指令，优先处理 clear 指令，确保新指令能够覆盖旧状态。
@@ -115,10 +82,14 @@ function expandInstructionSegments(instruction) {
     if (!trimmed) {
         return [];
     }
+    const normalizedLeading = normalizeInstructionLeading(trimmed);
     // stopMessage 指令需要整体解析，不能按逗号拆分，否则类似
     // "<**stopMessage:\"继续\",3**>" 会被错误拆成 ["stopMessage:\"继续\"", "3"]。
-    if (/^stopMessage\s*:/i.test(trimmed) || /^precommand(?:\s*:|$)/i.test(trimmed)) {
-        return [trimmed];
+    if (/^(?:"|')?stopMessage(?:"|')?\s*[:,]/i.test(normalizedLeading)) {
+        return [normalizeStopMessageCommandPrefix(normalizedLeading)];
+    }
+    if (/^precommand(?:\s*:|$)/i.test(normalizedLeading)) {
+        return [normalizedLeading];
     }
     const prefix = trimmed[0];
     if (prefix === '!' || prefix === '#' || prefix === '@') {
@@ -128,7 +99,12 @@ function expandInstructionSegments(instruction) {
             .filter((token) => token.length > 0)
             .map((token) => `${prefix}${token}`);
     }
-    return splitInstructionTargets(trimmed);
+    const splitTokens = splitInstructionTargets(trimmed);
+    const recoveredStopMessage = recoverSplitStopMessageInstruction(splitTokens);
+    if (recoveredStopMessage) {
+        return [recoveredStopMessage];
+    }
+    return splitTokens;
 }
 function splitInstructionTargets(content) {
     return content
@@ -136,6 +112,33 @@ function splitInstructionTargets(content) {
         .map((segment) => segment.trim())
         .filter((segment) => segment.length > 0);
 }
+function normalizeInstructionLeading(content) {
+    // Remove common zero-width prefixes that may be injected by client/editor copies.
+    return content.replace(/^[\u200B-\u200D\u2060\uFEFF]+/, '').trimStart();
+}
+function normalizeStopMessageCommandPrefix(content) {
+    const normalized = normalizeInstructionLeading(content);
+    return normalized.replace(/^(?:"|')?stopMessage(?:"|')?\s*([:,])/i, 'stopMessage$1');
+}
+function normalizeSplitStopMessageHeadToken(token) {
+    return normalizeInstructionLeading(token)
+        .replace(/^["']+|["']+$/g, '')
+        .trim();
+}
+function recoverSplitStopMessageInstruction(tokens) {
+    if (!Array.isArray(tokens) || tokens.length < 2) {
+        return null;
+    }
+    const head = normalizeSplitStopMessageHeadToken(tokens[0]);
+    if (!/^stopmessage$/i.test(head)) {
+        return null;
+    }
+    const tail = tokens.slice(1).join(',').trim();
+    if (!tail) {
+        return null;
+    }
+    return `stopMessage:${tail}`;
+}
 function splitTargetAndProcessMode(rawTarget) {
     const trimmed = typeof rawTarget === 'string' ? rawTarget.trim() : '';
     if (!trimmed) {
@@ -179,7 +182,7 @@ function parseNamedTargetInstruction(instruction, prefix) {
     return { type: prefix, ...normalized, ...(processMode ? { processMode } : {}) };
 }
 function parseSingleInstruction(instruction) {
-    if (instruction === 'clear') {
+    if (/^clear$/i.test(instruction)) {
         return { type: 'clear' };
     }
     const preCommandInstruction = parsePreCommandInstruction(instruction);
@@ -260,6 +263,33 @@ function parseSingleInstruction(instruction) {
     }
     return null;
 }
+function normalizeStopMessageInstructionPrecedence(instructions) {
+    if (!Array.isArray(instructions) || instructions.length <= 1) {
+        return instructions;
+    }
+    const isStopDirective = (inst) => inst.type === 'stopMessageSet' || inst.type === 'stopMessageMode' || inst.type === 'stopMessageClear';
+    const hasGlobalClear = instructions.some((inst) => inst.type === 'clear');
+    const hasStopClear = instructions.some((inst) => inst.type === 'stopMessageClear');
+    if (hasGlobalClear) {
+        const lastGlobalClearIndex = instructions.map((inst) => inst.type).lastIndexOf('clear');
+        return lastGlobalClearIndex >= 0 ? [instructions[lastGlobalClearIndex]] : instructions;
+    }
+    if (hasStopClear) {
+        const lastStopClearIndex = instructions.map((inst) => inst.type).lastIndexOf('stopMessageClear');
+        return lastStopClearIndex >= 0 ? [instructions[lastStopClearIndex]] : instructions;
+    }
+    let lastStopIndex = -1;
+    for (let idx = instructions.length - 1; idx >= 0; idx -= 1) {
+        if (isStopDirective(instructions[idx])) {
+            lastStopIndex = idx;
+            break;
+        }
+    }
+    if (lastStopIndex < 0) {
+        return instructions;
+    }
+    return instructions.filter((inst, idx) => !isStopDirective(inst) || idx === lastStopIndex);
+}
 function parseTarget(target) {
     if (!target) {
         return null;
@@ -375,14 +405,14 @@ export function applyRoutingInstructions(instructions, currentState) {
         stopMessageUsed: currentState.stopMessageUsed,
         stopMessageUpdatedAt: currentState.stopMessageUpdatedAt,
         stopMessageLastUsedAt: currentState.stopMessageLastUsedAt,
-        stopMessageStage: currentState.stopMessageStage,
         stopMessageStageMode: currentState.stopMessageStageMode,
-        stopMessageObservationHash: currentState.stopMessageObservationHash,
-        stopMessageObservationStableCount: currentState.stopMessageObservationStableCount,
-        stopMessageBdWorkState: currentState.stopMessageBdWorkState,
-        stopMessageAssignedIssueId: currentState.stopMessageAssignedIssueId,
-        stopMessageAssignedIssueSource: currentState.stopMessageAssignedIssueSource,
-        stopMessageNoTaskSummaryUsed: currentState.stopMessageNoTaskSummaryUsed,
+        stopMessageAiMode: currentState.stopMessageAiMode,
+        stopMessageAiSeedPrompt: currentState.stopMessageAiSeedPrompt,
+        stopMessageAiHistory: Array.isArray(currentState.stopMessageAiHistory)
+            ? currentState.stopMessageAiHistory.map((entry) => entry && typeof entry === 'object' && !Array.isArray(entry)
+                ? { ...entry }
+                : {})
+            : undefined,
         preCommandSource: currentState.preCommandSource,
         preCommandScriptPath: currentState.preCommandScriptPath,
         preCommandUpdatedAt: currentState.preCommandUpdatedAt
@@ -534,7 +564,7 @@ export function cleanMessagesFromRoutingInstructions(messages) {
         if (message.role !== 'user' || typeof message.content !== 'string') {
             return message;
         }
-        const cleanedContent = message.content.replace(/<\*\*[^*]+\*\*>/g, '').trim();
+        const cleanedContent = message.content.replace(ROUTING_INSTRUCTION_MARKER_GLOBAL_PATTERN, '').trim();
         return {
             ...message,
             content: cleanedContent
@@ -582,13 +612,10 @@ export function deserializeRoutingInstructionState(data) {
         stopMessageSource: undefined,
         stopMessageMaxRepeats: undefined,
         stopMessageUsed: undefined,
-        stopMessageStage: undefined,
         stopMessageStageMode: undefined,
-        stopMessageObservationHash: undefined,
-        stopMessageBdWorkState: undefined,
-        stopMessageAssignedIssueId: undefined,
-        stopMessageAssignedIssueSource: undefined,
-        stopMessageNoTaskSummaryUsed: undefined,
+        stopMessageAiMode: undefined,
+        stopMessageAiSeedPrompt: undefined,
+        stopMessageAiHistory: undefined,
         preCommandSource: undefined,
         preCommandScriptPath: undefined,
         preCommandUpdatedAt: undefined

package/dist/router/virtual-router/routing-stop-message-actions.js

@@ -1,120 +1,99 @@
-import { DEFAULT_STOP_MESSAGE_MAX_REPEATS, ensureStopMessageModeMaxRepeats, normalizeStopMessageStageMode } from './routing-stop-message-state-codec.js';
+import { normalizeStopMessageStageMode } from './routing-stop-message-state-codec.js';
+import { applyStopMessageInstructionWithNative } from './engine-selection/native-virtual-router-stop-message-actions-semantics.js';
+const STOP_MESSAGE_FIELDS = [
+    'stopMessageSource',
+    'stopMessageText',
+    'stopMessageMaxRepeats',
+    'stopMessageUsed',
+    'stopMessageUpdatedAt',
+    'stopMessageLastUsedAt',
+    'stopMessageStageMode',
+    'stopMessageAiMode',
+    'stopMessageAiSeedPrompt',
+    'stopMessageAiHistory'
+];
+const SKIP_PATCH_VALUE = Symbol('skipPatchValue');
 export function applyStopMessageInstructionToState(instruction, state) {
-    switch (instruction.type) {
-        case 'stopMessageSet': {
-            const text = typeof instruction.stopMessageText === 'string' && instruction.stopMessageText.trim()
-                ? instruction.stopMessageText.trim()
-                : '';
-            const maxRepeats = typeof instruction.stopMessageMaxRepeats === 'number' && Number.isFinite(instruction.stopMessageMaxRepeats)
-                ? Math.floor(instruction.stopMessageMaxRepeats)
-                : 0;
-            if (!text || maxRepeats <= 0) {
-                return true;
-            }
-            const incomingMode = normalizeStopMessageStageMode(instruction.stopMessageStageMode);
-            const currentMode = normalizeStopMessageStageMode(state.stopMessageStageMode);
-            const targetMode = incomingMode ?? (currentMode === 'off' ? 'on' : currentMode);
-            const sameText = typeof state.stopMessageText === 'string' && state.stopMessageText.trim() === text;
-            const sameMax = typeof state.stopMessageMaxRepeats === 'number' &&
-                Math.floor(state.stopMessageMaxRepeats) === maxRepeats;
-            const sameMode = currentMode === targetMode;
-            const isSameInstruction = sameText && sameMax && sameMode;
-            const used = typeof state.stopMessageUsed === 'number' && Number.isFinite(state.stopMessageUsed)
-                ? Math.max(0, Math.floor(state.stopMessageUsed))
-                : 0;
-            const hasLastUsedAt = typeof state.stopMessageLastUsedAt === 'number' && Number.isFinite(state.stopMessageLastUsedAt);
-            const shouldRearm = !isSameInstruction || used > 0 || hasLastUsedAt;
-            const shouldRearmForSource = instruction.fromHistoricalUserMessage
-                ? !isSameInstruction
-                : shouldRearm;
-            state.stopMessageText = text;
-            state.stopMessageMaxRepeats = maxRepeats;
-            state.stopMessageSource = 'explicit';
-            if (targetMode) {
-                state.stopMessageStageMode = targetMode;
-            }
-            if (shouldRearmForSource) {
-                resetStopMessageRuntimeState(state, Date.now());
-            }
-            return true;
+    const nowMs = Date.now();
+    const before = snapshotStopMessageState(state);
+    const patch = applyStopMessageInstructionWithNative(instruction, before, nowMs);
+    applyStopMessagePatch(state, patch);
+    return patch.applied;
+}
+function snapshotStopMessageState(state) {
+    return {
+        stopMessageSource: state.stopMessageSource,
+        stopMessageText: state.stopMessageText,
+        stopMessageMaxRepeats: state.stopMessageMaxRepeats,
+        stopMessageUsed: state.stopMessageUsed,
+        stopMessageUpdatedAt: state.stopMessageUpdatedAt,
+        stopMessageLastUsedAt: state.stopMessageLastUsedAt,
+        stopMessageStageMode: state.stopMessageStageMode,
+        stopMessageAiMode: state.stopMessageAiMode,
+        stopMessageAiSeedPrompt: state.stopMessageAiSeedPrompt,
+        stopMessageAiHistory: Array.isArray(state.stopMessageAiHistory) ? cloneHistory(state.stopMessageAiHistory) : undefined
+    };
+}
+function applyStopMessagePatch(state, patch) {
+    for (const field of patch.unset) {
+        if (!STOP_MESSAGE_FIELDS.includes(field)) {
+            continue;
         }
-        case 'stopMessageMode': {
-            const mode = normalizeStopMessageStageMode(instruction.stopMessageStageMode);
-            if (!mode) {
-                return true;
-            }
-            const explicitMaxRepeats = typeof instruction.stopMessageMaxRepeats === 'number' && Number.isFinite(instruction.stopMessageMaxRepeats)
-                ? Math.floor(instruction.stopMessageMaxRepeats)
-                : undefined;
-            if (mode === 'off') {
-                clearStopMessageState(state, { keepMode: 'off' });
-                return true;
-            }
-            const previousMode = normalizeStopMessageStageMode(state.stopMessageStageMode);
-            const previousMax = typeof state.stopMessageMaxRepeats === 'number' && Number.isFinite(state.stopMessageMaxRepeats)
-                ? Math.floor(state.stopMessageMaxRepeats)
-                : undefined;
-            const preservedMax = typeof state.stopMessageMaxRepeats === 'number' && Number.isFinite(state.stopMessageMaxRepeats)
-                ? Math.floor(state.stopMessageMaxRepeats)
-                : undefined;
-            const resolvedMax = typeof explicitMaxRepeats === 'number' && explicitMaxRepeats > 0
-                ? explicitMaxRepeats
-                : typeof preservedMax === 'number' && preservedMax > 0
-                    ? preservedMax
-                    : mode === 'on' || mode === 'auto'
-                        ? DEFAULT_STOP_MESSAGE_MAX_REPEATS
-                        : undefined;
-            state.stopMessageStageMode = mode;
-            state.stopMessageSource = 'explicit';
-            state.stopMessageMaxRepeats = resolvedMax;
-            ensureStopMessageModeMaxRepeats(state);
-            const nextMax = typeof state.stopMessageMaxRepeats === 'number' && Number.isFinite(state.stopMessageMaxRepeats)
-                ? Math.floor(state.stopMessageMaxRepeats)
-                : undefined;
-            const shouldRearm = previousMode !== mode ||
-                previousMax !== nextMax ||
-                typeof state.stopMessageUsed !== 'number' ||
-                !Number.isFinite(state.stopMessageUsed);
-            const shouldRearmForSource = instruction.fromHistoricalUserMessage
-                ? (previousMode !== mode || previousMax !== nextMax || typeof state.stopMessageUsed !== 'number' || !Number.isFinite(state.stopMessageUsed))
-                : shouldRearm;
-            if (shouldRearmForSource) {
-                resetStopMessageRuntimeState(state, Date.now());
+        state[field] = undefined;
+    }
+    for (const [field, rawValue] of Object.entries(patch.set)) {
+        const value = coerceStopMessagePatchValue(field, rawValue);
+        if (value === SKIP_PATCH_VALUE) {
+            continue;
+        }
+        state[field] = value;
+    }
+}
+function coerceStopMessagePatchValue(field, value) {
+    switch (field) {
+        case 'stopMessageSource':
+        case 'stopMessageText':
+        case 'stopMessageAiSeedPrompt':
+            return typeof value === 'string' ? value : SKIP_PATCH_VALUE;
+        case 'stopMessageStageMode': {
+            const normalized = normalizeStopMessageStageMode(value);
+            return normalized ?? SKIP_PATCH_VALUE;
+        }
+        case 'stopMessageAiMode': {
+            const normalizedAiMode = normalizeStopMessageAiMode(value);
+            return normalizedAiMode ?? SKIP_PATCH_VALUE;
+        }
+        case 'stopMessageMaxRepeats':
+        case 'stopMessageUsed':
+        case 'stopMessageUpdatedAt':
+        case 'stopMessageLastUsedAt':
+            return typeof value === 'number' && Number.isFinite(value) ? value : SKIP_PATCH_VALUE;
+        case 'stopMessageAiHistory': {
+            if (!Array.isArray(value)) {
+                return SKIP_PATCH_VALUE;
             }
-            return true;
+            return cloneHistory(value);
         }
-        case 'stopMessageClear':
-            clearStopMessageState(state);
-            return true;
-        default:
-            return false;
     }
+    return SKIP_PATCH_VALUE;
 }
-function resetStopMessageRuntimeState(state, atMs) {
-    state.stopMessageUsed = 0;
-    state.stopMessageUpdatedAt = atMs;
-    state.stopMessageLastUsedAt = undefined;
-    state.stopMessageStage = undefined;
-    state.stopMessageObservationHash = undefined;
-    state.stopMessageObservationStableCount = 0;
-    state.stopMessageBdWorkState = undefined;
-    state.stopMessageAssignedIssueId = undefined;
-    state.stopMessageAssignedIssueSource = undefined;
-    state.stopMessageNoTaskSummaryUsed = undefined;
+function cloneHistory(value) {
+    const out = [];
+    for (const item of value) {
+        if (!item || typeof item !== 'object' || Array.isArray(item)) {
+            continue;
+        }
+        out.push({ ...item });
+    }
+    return out;
 }
-function clearStopMessageState(state, options) {
-    state.stopMessageText = undefined;
-    state.stopMessageMaxRepeats = undefined;
-    state.stopMessageUsed = undefined;
-    state.stopMessageSource = undefined;
-    state.stopMessageUpdatedAt = undefined;
-    state.stopMessageLastUsedAt = undefined;
-    state.stopMessageStage = undefined;
-    state.stopMessageStageMode = options?.keepMode;
-    state.stopMessageObservationHash = undefined;
-    state.stopMessageObservationStableCount = undefined;
-    state.stopMessageBdWorkState = undefined;
-    state.stopMessageAssignedIssueId = undefined;
-    state.stopMessageAssignedIssueSource = undefined;
-    state.stopMessageNoTaskSummaryUsed = undefined;
+function normalizeStopMessageAiMode(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'on' || normalized === 'off') {
+        return normalized;
+    }
+    return undefined;
 }

package/dist/router/virtual-router/routing-stop-message-parser.js

@@ -1,142 +1,19 @@
-import { resolveStopMessageText } from './stop-message-file-resolver.js';
+import { isStopMessageFileReference, resolveStopMessageText } from './stop-message-file-resolver.js';
+import { parseStopMessageInstructionWithNative } from './engine-selection/native-virtual-router-stop-message-semantics.js';
 export const DEFAULT_STOP_MESSAGE_MAX_REPEATS = 10;
 export function parseStopMessageInstruction(instruction) {
-    if (!/^stopMessage\s*:/i.test(instruction)) {
+    const resolved = parseStopMessageInstructionWithNative(instruction);
+    if (!resolved) {
         return null;
     }
-    const body = instruction.slice('stopMessage'.length + 1).trim();
-    if (!body) {
-        return null;
-    }
-    if (/^clear$/i.test(body)) {
+    if (resolved.kind === 'clear') {
         return { type: 'stopMessageClear' };
     }
-    const modeOnly = parseStopMessageModeWithOptionalRepeats(body);
-    if (modeOnly) {
-        return {
-            type: 'stopMessageMode',
-            stopMessageStageMode: modeOnly.mode,
-            ...(typeof modeOnly.maxRepeats === 'number' ? { stopMessageMaxRepeats: modeOnly.maxRepeats } : {})
-        };
-    }
-    let text = '';
-    let maxRepeats = DEFAULT_STOP_MESSAGE_MAX_REPEATS;
-    let cursor = body;
-    let stageMode;
-    if (cursor[0] === '"') {
-        let escaped = false;
-        let endIndex = -1;
-        for (let i = 1; i < cursor.length; i += 1) {
-            const ch = cursor[i];
-            if (escaped) {
-                escaped = false;
-                continue;
-            }
-            if (ch === '\\') {
-                escaped = true;
-                continue;
-            }
-            if (ch === '"') {
-                endIndex = i;
-                break;
-            }
-        }
-        if (endIndex <= 0) {
-            return null;
-        }
-        const rawText = cursor.slice(1, endIndex);
-        text = rawText.replace(/\\"/g, '"');
-        cursor = cursor.slice(endIndex + 1).trim();
-        if (cursor.startsWith(',')) {
-            const tail = cursor.slice(1).trim();
-            const parsedTail = parseStopMessageTail(tail);
-            maxRepeats = parsedTail.maxRepeats;
-            stageMode = parsedTail.stageMode;
-        }
-    }
-    else {
-        const parts = cursor
-            .split(',')
-            .map((part) => part.trim())
-            .filter(Boolean);
-        if (!parts.length) {
-            return null;
-        }
-        text = parts[0];
-        const parsedTail = parseStopMessageTail(parts.slice(1));
-        maxRepeats = parsedTail.maxRepeats;
-        stageMode = parsedTail.stageMode;
-    }
-    if (!text) {
-        return null;
-    }
     return {
         type: 'stopMessageSet',
-        stopMessageText: resolveStopMessageText(text),
-        stopMessageMaxRepeats: maxRepeats,
-        ...(stageMode ? { stopMessageStageMode: stageMode } : {})
-    };
-}
-function parseStopMessageTail(input) {
-    const tokens = Array.isArray(input)
-        ? input.map((part) => part.trim()).filter(Boolean)
-        : input
-            .split(',')
-            .map((part) => part.trim())
-            .filter(Boolean);
-    let maxRepeats = DEFAULT_STOP_MESSAGE_MAX_REPEATS;
-    let stageMode;
-    for (const token of tokens) {
-        const mode = parseStopMessageStageModeToken(token);
-        if (mode) {
-            stageMode = mode;
-            continue;
-        }
-        const parsed = Number.parseInt(token, 10);
-        if (!Number.isNaN(parsed) && parsed > 0) {
-            maxRepeats = parsed;
-        }
-    }
-    return {
-        maxRepeats,
-        ...(stageMode ? { stageMode } : {})
+        stopMessageText: resolveStopMessageText(resolved.text),
+        stopMessageMaxRepeats: resolved.maxRepeats,
+        stopMessageSource: isStopMessageFileReference(resolved.text) ? 'explicit_file' : 'explicit_text',
+        ...(resolved.aiMode ? { stopMessageAiMode: resolved.aiMode } : {})
     };
 }
-function parseStopMessageModeWithOptionalRepeats(value) {
-    const normalized = value.trim().toLowerCase();
-    const match = normalized.match(/^(?:(?:stage|mode)\s*[:=]\s*)?(on|off|auto)\s*(?:,\s*(\d+)\s*)?$/i);
-    if (!match) {
-        return null;
-    }
-    const token = match[1].trim().toLowerCase();
-    const mode = token === 'on' || token === 'off' || token === 'auto'
-        ? token
-        : undefined;
-    if (!mode) {
-        return null;
-    }
-    if (mode === 'off') {
-        return { mode };
-    }
-    const repeatToken = match[2];
-    if (!repeatToken) {
-        return { mode, maxRepeats: DEFAULT_STOP_MESSAGE_MAX_REPEATS };
-    }
-    const parsed = Number.parseInt(repeatToken, 10);
-    if (Number.isNaN(parsed) || parsed <= 0) {
-        return { mode, maxRepeats: DEFAULT_STOP_MESSAGE_MAX_REPEATS };
-    }
-    return { mode, maxRepeats: parsed };
-}
-function parseStopMessageStageModeToken(value) {
-    const normalized = value.trim().toLowerCase();
-    const match = normalized.match(/^(?:(?:stage|mode)\s*[:=]\s*)?(on|off|auto)$/i);
-    if (!match) {
-        return undefined;
-    }
-    const token = match[1].trim().toLowerCase();
-    if (token === 'on' || token === 'off' || token === 'auto') {
-        return token;
-    }
-    return undefined;
-}

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

@@ -4,3 +4,4 @@ export declare function serializeStopMessageState(state: RoutingInstructionState
 export declare function deserializeStopMessageState(data: Record<string, unknown>, state: RoutingInstructionState): void;
 export declare function normalizeStopMessageStageMode(value: unknown): 'on' | 'off' | 'auto' | undefined;
 export declare function ensureStopMessageModeMaxRepeats(state: RoutingInstructionState): boolean;
+export declare function normalizeStopMessageAiMode(value: unknown): 'on' | 'off' | undefined;