@jsonstudio/llms 0.6.1739 → 0.6.1890

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

@@ -7,6 +7,7 @@ import { ContextAdvisor } from './context-advisor.js';
 import { DEFAULT_ROUTE, ROUTE_PRIORITY, VirtualRouterError, VirtualRouterErrorCode } from './types.js';
 import { getStatsCenter } from '../../telemetry/stats-center.js';
 import { parseRoutingInstructions, applyRoutingInstructions, cleanMessagesFromRoutingInstructions } from './routing-instructions.js';
+import { extractMessageText } from './message-utils.js';
 import { loadRoutingInstructionStateSync, saveRoutingInstructionStateAsync, saveRoutingInstructionStateSync } from './sticky-session-store.js';
 import { buildHitReason, formatVirtualRouterHit } from './engine-logging.js';
 import { selectDirectProviderModel, selectFromStickyPool, selectProviderImpl } from './engine/routing-pools/index.js';
@@ -14,8 +15,74 @@ import { applyQuotaDepletedImpl, applyQuotaRecoveryImpl, applySeriesCooldownImpl
 import { hydrateAntigravityAliasLeaseStoreIfNeeded, recordAntigravitySessionLease, resolveAntigravityAliasReuseCooldownMs } from './engine/antigravity/alias-lease.js';
 import { buildMetadataInstructions, resolveRoutingMode } from './engine/routing-state/metadata.js';
 import { getRoutingInstructionState, persistRoutingInstructionState, resolveStopMessageScope } from './engine/routing-state/store.js';
+import { validateStopMessageStageTemplatesCompleteness } from './stop-message-stage-template-files.js';
 import { extractKeyAlias, extractKeyIndex, extractProviderId, getProviderModelId } from './engine/provider-key/parse.js';
 import { resolveSessionScope as resolveSessionScopeImpl, resolveStickyKey as resolveStickyKeyImpl } from './engine/routing-state/keys.js';
+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 resolveStopMessageStageModeAfterInstructions(instructions, currentMode) {
+    let mode = normalizeStopMessageStageMode(currentMode);
+    for (const instruction of instructions) {
+        if (instruction.type === 'stopMessageClear') {
+            mode = undefined;
+            continue;
+        }
+        if (instruction.type === 'stopMessageMode') {
+            const incomingMode = normalizeStopMessageStageMode(instruction.stopMessageStageMode);
+            if (incomingMode) {
+                mode = incomingMode;
+            }
+            continue;
+        }
+        if (instruction.type === 'stopMessageSet') {
+            const incomingMode = normalizeStopMessageStageMode(instruction.stopMessageStageMode);
+            if (incomingMode) {
+                mode = incomingMode;
+            }
+            else if (mode === 'off') {
+                mode = 'on';
+            }
+        }
+    }
+    return mode;
+}
+function hasRoutingInstructionMarker(messages) {
+    for (const message of messages) {
+        if (!message || message.role !== 'user') {
+            continue;
+        }
+        const content = extractMessageText(message);
+        if (!content) {
+            continue;
+        }
+        if (/<\*\*[^*]+\*\*>/.test(content)) {
+            return true;
+        }
+    }
+    return false;
+}
+function hasLatestUserRoutingInstructionMarker(messages) {
+    for (let idx = messages.length - 1; idx >= 0; idx -= 1) {
+        const message = messages[idx];
+        if (!message || message.role !== 'user') {
+            continue;
+        }
+        const content = extractMessageText(message);
+        if (!content) {
+            return false;
+        }
+        return /<\*\*[^*]+\*\*>/.test(content);
+    }
+    return false;
+}
 export class VirtualRouterEngine {
     routing = {};
     providerRegistry = new ProviderRegistry();
@@ -165,34 +232,68 @@ export class VirtualRouterEngine {
         if (stopMessageScope) {
             const sessionState = getRoutingInstructionState(stopMessageScope, this.routingInstructionState, this.routingStateStore);
             if (typeof sessionState.stopMessageText === 'string' ||
-                typeof sessionState.stopMessageMaxRepeats === 'number') {
+                typeof sessionState.stopMessageMaxRepeats === 'number' ||
+                typeof sessionState.stopMessageStageMode === 'string') {
                 routingState = {
                     ...routingState,
                     stopMessageText: sessionState.stopMessageText,
                     stopMessageMaxRepeats: sessionState.stopMessageMaxRepeats,
                     stopMessageUsed: sessionState.stopMessageUsed,
                     stopMessageUpdatedAt: sessionState.stopMessageUpdatedAt,
-                    stopMessageLastUsedAt: sessionState.stopMessageLastUsedAt
+                    stopMessageLastUsedAt: sessionState.stopMessageLastUsedAt,
+                    stopMessageStage: sessionState.stopMessageStage,
+                    stopMessageStageMode: sessionState.stopMessageStageMode,
+                    stopMessageObservationHash: sessionState.stopMessageObservationHash,
+                    stopMessageObservationStableCount: sessionState.stopMessageObservationStableCount,
+                    stopMessageBdWorkState: sessionState.stopMessageBdWorkState
+                };
+            }
+            if (typeof sessionState.preCommandScriptPath === 'string' && sessionState.preCommandScriptPath.trim()) {
+                routingState = {
+                    ...routingState,
+                    preCommandSource: sessionState.preCommandSource,
+                    preCommandScriptPath: sessionState.preCommandScriptPath,
+                    preCommandUpdatedAt: sessionState.preCommandUpdatedAt
                 };
             }
         }
         const parsedInstructions = parseRoutingInstructions(request.messages);
+        const latestUserHasMarker = hasLatestUserRoutingInstructionMarker(request.messages);
         let instructions = parsedInstructions;
         if (stopMessageScope && parsedInstructions.length > 0) {
             const sessionState = getRoutingInstructionState(stopMessageScope, this.routingInstructionState, this.routingStateStore);
-            const hasStopMessageClear = parsedInstructions.some((entry) => entry.type === 'stopMessageClear');
-            const stopMessageSets = parsedInstructions.filter((entry) => entry.type === 'stopMessageSet');
+            const hasStaleStopMessageInstruction = !latestUserHasMarker &&
+                parsedInstructions.some((entry) => entry.type === 'stopMessageSet' ||
+                    entry.type === 'stopMessageMode' ||
+                    entry.type === 'stopMessageClear');
+            if (hasStaleStopMessageInstruction) {
+                const hasActiveStopState = typeof sessionState.stopMessageText === 'string' ||
+                    typeof sessionState.stopMessageMaxRepeats === 'number' ||
+                    typeof sessionState.stopMessageStageMode === 'string';
+                const hasStopLifecycleStamp = (typeof sessionState.stopMessageUpdatedAt === 'number' && Number.isFinite(sessionState.stopMessageUpdatedAt)) ||
+                    (typeof sessionState.stopMessageLastUsedAt === 'number' && Number.isFinite(sessionState.stopMessageLastUsedAt));
+                if (hasActiveStopState || hasStopLifecycleStamp) {
+                    instructions = instructions.filter((entry) => entry.type !== 'stopMessageSet' &&
+                        entry.type !== 'stopMessageMode' &&
+                        entry.type !== 'stopMessageClear');
+                }
+            }
+            const hasStopMessageClear = instructions.some((entry) => entry.type === 'stopMessageClear');
+            const stopMessageSets = instructions.filter((entry) => entry.type === 'stopMessageSet');
             if (!hasStopMessageClear && stopMessageSets.length > 0) {
                 const sessionText = typeof sessionState.stopMessageText === 'string' ? sessionState.stopMessageText.trim() : '';
                 const sessionMax = typeof sessionState.stopMessageMaxRepeats === 'number' && Number.isFinite(sessionState.stopMessageMaxRepeats)
                     ? Math.floor(sessionState.stopMessageMaxRepeats)
                     : undefined;
+                const sessionMode = normalizeStopMessageStageMode(sessionState.stopMessageStageMode);
                 const allSame = stopMessageSets.every((entry) => {
                     const entryText = typeof entry.stopMessageText === 'string' ? entry.stopMessageText.trim() : '';
                     const entryMax = typeof entry.stopMessageMaxRepeats === 'number' && Number.isFinite(entry.stopMessageMaxRepeats)
                         ? Math.floor(entry.stopMessageMaxRepeats)
                         : undefined;
-                    return Boolean(entryText) && entryText === sessionText && entryMax === sessionMax;
+                    const incomingMode = normalizeStopMessageStageMode(entry.stopMessageStageMode);
+                    const entryMode = incomingMode ?? (sessionMode === 'off' ? 'on' : sessionMode);
+                    return Boolean(entryText) && entryText === sessionText && entryMax === sessionMax && entryMode === sessionMode;
                 });
                 const used = typeof sessionState.stopMessageUsed === 'number' && Number.isFinite(sessionState.stopMessageUsed)
                     ? Math.max(0, Math.floor(sessionState.stopMessageUsed))
@@ -201,19 +302,36 @@ export class VirtualRouterEngine {
                     Number.isFinite(sessionState.stopMessageLastUsedAt);
                 const alreadyArmed = used === 0 && !hasLastUsedAt;
                 if (allSame && alreadyArmed) {
-                    instructions = parsedInstructions.filter((entry) => entry.type !== 'stopMessageSet');
+                    instructions = instructions.filter((entry) => entry.type !== 'stopMessageSet');
                 }
             }
         }
         // stopMessage must be session-scoped: require explicit sessionId in metadata.
         // This prevents global/default persistence and ensures the trigger matches the setting sessionId.
         if (parsedInstructions.length > 0) {
-            const hasStopMessageInstruction = parsedInstructions.some((entry) => entry.type === 'stopMessageSet' || entry.type === 'stopMessageClear');
-            if (hasStopMessageInstruction && !stopMessageScope) {
-                throw new VirtualRouterError('[stopMessage] requires sessionId (e.g. set x-session-id header or metadata.sessionId).', VirtualRouterErrorCode.CONFIG_ERROR, { requestId: metadata.requestId, entryEndpoint: metadata.entryEndpoint });
+            const hasSessionScopedInstruction = parsedInstructions.some((entry) => entry.type === 'stopMessageSet' ||
+                entry.type === 'stopMessageMode' ||
+                entry.type === 'stopMessageClear' ||
+                entry.type === 'preCommandSet' ||
+                entry.type === 'preCommandClear');
+            if (hasSessionScopedInstruction && !stopMessageScope) {
+                throw new VirtualRouterError('[stopMessage/precommand] requires sessionId (e.g. set x-session-id header or metadata.sessionId).', VirtualRouterErrorCode.CONFIG_ERROR, { requestId: metadata.requestId, entryEndpoint: metadata.entryEndpoint });
             }
         }
-        if (parsedInstructions.length > 0) {
+        if (stopMessageScope && parsedInstructions.length > 0) {
+            const sessionState = getRoutingInstructionState(stopMessageScope, this.routingInstructionState, this.routingStateStore);
+            const nextStopMessageMode = resolveStopMessageStageModeAfterInstructions(instructions, sessionState.stopMessageStageMode);
+            if (nextStopMessageMode === 'on') {
+                const templateCheck = validateStopMessageStageTemplatesCompleteness();
+                if (!templateCheck.ok) {
+                    const detail = templateCheck.missing
+                        .map((entry) => `${entry.stage}:${entry.ref || '(no-ref)'}:${entry.error || 'invalid'}`)
+                        .join('; ');
+                    throw new VirtualRouterError(`[stopMessage] mode=on requires complete stage message files (${detail}).`, VirtualRouterErrorCode.CONFIG_ERROR, { requestId: metadata.requestId, entryEndpoint: metadata.entryEndpoint });
+                }
+            }
+        }
+        if (hasRoutingInstructionMarker(request.messages)) {
             request.messages = cleanMessagesFromRoutingInstructions(request.messages);
         }
         if (instructions.length > 0) {
@@ -226,8 +344,9 @@ export class VirtualRouterEngine {
             // so servertool triggers always match the setting sessionId.
             if (stopMessageScope) {
                 const hasStopMessageSet = instructions.some((entry) => entry.type === 'stopMessageSet');
+                const hasStopMessageMode = instructions.some((entry) => entry.type === 'stopMessageMode');
                 const hasStopMessageClear = instructions.some((entry) => entry.type === 'stopMessageClear');
-                if (hasStopMessageSet || hasStopMessageClear) {
+                if (hasStopMessageSet || hasStopMessageMode || hasStopMessageClear) {
                     const sessionState = getRoutingInstructionState(stopMessageScope, this.routingInstructionState, this.routingStateStore);
                     let nextSessionState = {
                         ...sessionState
@@ -241,6 +360,11 @@ export class VirtualRouterEngine {
                         nextSessionState.stopMessageUpdatedAt = clearedAt;
                         nextSessionState.stopMessageLastUsedAt = clearedAt;
                         nextSessionState.stopMessageSource = undefined;
+                        nextSessionState.stopMessageStage = undefined;
+                        nextSessionState.stopMessageStageMode = undefined;
+                        nextSessionState.stopMessageObservationHash = undefined;
+                        nextSessionState.stopMessageObservationStableCount = undefined;
+                        nextSessionState.stopMessageBdWorkState = undefined;
                         shouldPersistSessionState = true;
                     }
                     else if (hasStopMessageSet) {
@@ -251,7 +375,10 @@ export class VirtualRouterEngine {
                         const sameMax = typeof sessionState.stopMessageMaxRepeats === 'number' &&
                             typeof maxRepeats === 'number' &&
                             Math.floor(sessionState.stopMessageMaxRepeats) === Math.floor(maxRepeats);
-                        const isSameInstruction = Boolean(text) && sameText && sameMax;
+                        const currentMode = normalizeStopMessageStageMode(sessionState.stopMessageStageMode);
+                        const nextMode = normalizeStopMessageStageMode(routingState.stopMessageStageMode) ?? currentMode;
+                        const isSameMode = currentMode === nextMode;
+                        const isSameInstruction = Boolean(text) && sameText && sameMax && isSameMode;
                         const used = typeof sessionState.stopMessageUsed === 'number' && Number.isFinite(sessionState.stopMessageUsed)
                             ? Math.max(0, Math.floor(sessionState.stopMessageUsed))
                             : 0;
@@ -261,16 +388,62 @@ export class VirtualRouterEngine {
                         nextSessionState.stopMessageText = text || undefined;
                         nextSessionState.stopMessageMaxRepeats = maxRepeats;
                         nextSessionState.stopMessageSource = 'explicit';
+                        nextSessionState.stopMessageStageMode = nextMode;
                         if (shouldRearm) {
                             nextSessionState.stopMessageUsed = 0;
                             nextSessionState.stopMessageUpdatedAt =
                                 typeof routingState.stopMessageUpdatedAt === 'number'
                                     ? routingState.stopMessageUpdatedAt
                                     : Date.now();
+                            nextSessionState.stopMessageStage = undefined;
+                            nextSessionState.stopMessageObservationHash = undefined;
+                            nextSessionState.stopMessageObservationStableCount = 0;
+                            nextSessionState.stopMessageBdWorkState = undefined;
                             nextSessionState.stopMessageLastUsedAt = undefined;
                             shouldPersistSessionState = true;
                         }
                     }
+                    else if (hasStopMessageMode) {
+                        const mode = normalizeStopMessageStageMode(routingState.stopMessageStageMode);
+                        const modeMaxRepeats = typeof routingState.stopMessageMaxRepeats === 'number' && Number.isFinite(routingState.stopMessageMaxRepeats)
+                            ? Math.floor(routingState.stopMessageMaxRepeats)
+                            : 0;
+                        if (mode === 'off') {
+                            const changed = typeof nextSessionState.stopMessageText === 'string' ||
+                                typeof nextSessionState.stopMessageMaxRepeats === 'number' ||
+                                typeof nextSessionState.stopMessageUsed === 'number' ||
+                                typeof nextSessionState.stopMessageSource === 'string' ||
+                                typeof nextSessionState.stopMessageStage === 'string' ||
+                                typeof nextSessionState.stopMessageObservationHash === 'string' ||
+                                typeof nextSessionState.stopMessageObservationStableCount === 'number' ||
+                                typeof nextSessionState.stopMessageBdWorkState === 'string' ||
+                                normalizeStopMessageStageMode(nextSessionState.stopMessageStageMode) !== 'off';
+                            nextSessionState.stopMessageText = undefined;
+                            nextSessionState.stopMessageMaxRepeats = undefined;
+                            nextSessionState.stopMessageUsed = undefined;
+                            nextSessionState.stopMessageSource = undefined;
+                            nextSessionState.stopMessageStage = undefined;
+                            nextSessionState.stopMessageStageMode = 'off';
+                            nextSessionState.stopMessageObservationHash = undefined;
+                            nextSessionState.stopMessageObservationStableCount = undefined;
+                            nextSessionState.stopMessageBdWorkState = undefined;
+                            nextSessionState.stopMessageUpdatedAt = Date.now();
+                            nextSessionState.stopMessageLastUsedAt = undefined;
+                            shouldPersistSessionState = changed;
+                        }
+                        else if (mode) {
+                            if (normalizeStopMessageStageMode(nextSessionState.stopMessageStageMode) !== mode) {
+                                nextSessionState.stopMessageStageMode = mode;
+                                shouldPersistSessionState = true;
+                            }
+                            if (modeMaxRepeats > 0 &&
+                                (typeof nextSessionState.stopMessageMaxRepeats !== 'number' ||
+                                    Math.floor(nextSessionState.stopMessageMaxRepeats) !== modeMaxRepeats)) {
+                                nextSessionState.stopMessageMaxRepeats = modeMaxRepeats;
+                                shouldPersistSessionState = true;
+                            }
+                        }
+                    }
                     if (shouldPersistSessionState) {
                         this.routingInstructionState.set(stopMessageScope, nextSessionState);
                         persistRoutingInstructionState(stopMessageScope, nextSessionState, this.routingStateStore);
@@ -280,25 +453,83 @@ export class VirtualRouterEngine {
                     }
                     // 日志展示使用 session scope 的 stopMessage 状态，避免每次解析重复刷新时间/次数。
                     if (typeof nextSessionState.stopMessageText === 'string' ||
-                        typeof nextSessionState.stopMessageMaxRepeats === 'number') {
+                        typeof nextSessionState.stopMessageMaxRepeats === 'number' ||
+                        typeof nextSessionState.stopMessageStageMode === 'string') {
                         routingState.stopMessageText = nextSessionState.stopMessageText;
                         routingState.stopMessageMaxRepeats = nextSessionState.stopMessageMaxRepeats;
                         routingState.stopMessageUsed = nextSessionState.stopMessageUsed;
                         routingState.stopMessageUpdatedAt = nextSessionState.stopMessageUpdatedAt;
                         routingState.stopMessageLastUsedAt = nextSessionState.stopMessageLastUsedAt;
+                        routingState.stopMessageStage = nextSessionState.stopMessageStage;
+                        routingState.stopMessageStageMode = nextSessionState.stopMessageStageMode;
+                        routingState.stopMessageObservationHash = nextSessionState.stopMessageObservationHash;
+                        routingState.stopMessageObservationStableCount = nextSessionState.stopMessageObservationStableCount;
+                        routingState.stopMessageBdWorkState = nextSessionState.stopMessageBdWorkState;
                     }
                 }
             }
         }
+        if (instructions.length > 0 && stopMessageScope) {
+            const hasPreCommandSet = instructions.some((entry) => entry.type === 'preCommandSet');
+            const hasPreCommandClear = instructions.some((entry) => entry.type === 'preCommandClear');
+            if (hasPreCommandSet || hasPreCommandClear) {
+                const sessionState = getRoutingInstructionState(stopMessageScope, this.routingInstructionState, this.routingStateStore);
+                const nextSessionState = {
+                    ...sessionState
+                };
+                let changed = false;
+                if (hasPreCommandClear) {
+                    changed =
+                        typeof sessionState.preCommandScriptPath === 'string' ||
+                            typeof sessionState.preCommandSource === 'string' ||
+                            typeof sessionState.preCommandUpdatedAt === 'number';
+                    nextSessionState.preCommandScriptPath = undefined;
+                    nextSessionState.preCommandSource = undefined;
+                    nextSessionState.preCommandUpdatedAt = Date.now();
+                }
+                if (hasPreCommandSet) {
+                    const scriptPath = typeof routingState.preCommandScriptPath === 'string' ? routingState.preCommandScriptPath.trim() : '';
+                    if (scriptPath) {
+                        if (sessionState.preCommandScriptPath !== scriptPath) {
+                            changed = true;
+                        }
+                        nextSessionState.preCommandScriptPath = scriptPath;
+                        nextSessionState.preCommandSource = 'explicit';
+                        nextSessionState.preCommandUpdatedAt =
+                            typeof routingState.preCommandUpdatedAt === 'number' && Number.isFinite(routingState.preCommandUpdatedAt)
+                                ? routingState.preCommandUpdatedAt
+                                : Date.now();
+                    }
+                }
+                if (changed) {
+                    this.routingInstructionState.set(stopMessageScope, nextSessionState);
+                    persistRoutingInstructionState(stopMessageScope, nextSessionState, this.routingStateStore);
+                    routingState.preCommandScriptPath = nextSessionState.preCommandScriptPath;
+                    routingState.preCommandSource = nextSessionState.preCommandSource;
+                    routingState.preCommandUpdatedAt = nextSessionState.preCommandUpdatedAt;
+                }
+            }
+        }
         if (instructions.length === 0 && stopMessageScope) {
             const sessionState = getRoutingInstructionState(stopMessageScope, this.routingInstructionState, this.routingStateStore);
             if (typeof sessionState.stopMessageText === 'string' ||
-                typeof sessionState.stopMessageMaxRepeats === 'number') {
+                typeof sessionState.stopMessageMaxRepeats === 'number' ||
+                typeof sessionState.stopMessageStageMode === 'string') {
                 routingState.stopMessageText = sessionState.stopMessageText;
                 routingState.stopMessageMaxRepeats = sessionState.stopMessageMaxRepeats;
                 routingState.stopMessageUsed = sessionState.stopMessageUsed;
                 routingState.stopMessageUpdatedAt = sessionState.stopMessageUpdatedAt;
                 routingState.stopMessageLastUsedAt = sessionState.stopMessageLastUsedAt;
+                routingState.stopMessageStage = sessionState.stopMessageStage;
+                routingState.stopMessageStageMode = sessionState.stopMessageStageMode;
+                routingState.stopMessageObservationHash = sessionState.stopMessageObservationHash;
+                routingState.stopMessageObservationStableCount = sessionState.stopMessageObservationStableCount;
+                routingState.stopMessageBdWorkState = sessionState.stopMessageBdWorkState;
+            }
+            if (typeof sessionState.preCommandScriptPath === 'string' && sessionState.preCommandScriptPath.trim()) {
+                routingState.preCommandScriptPath = sessionState.preCommandScriptPath;
+                routingState.preCommandSource = sessionState.preCommandSource;
+                routingState.preCommandUpdatedAt = sessionState.preCommandUpdatedAt;
             }
         }
         // Guardrail: if a session is restricted to providers that do not exist in any routing pools,
@@ -517,12 +748,16 @@ export class VirtualRouterEngine {
             }
         }
         const baseTarget = this.providerRegistry.buildTarget(selection.providerKey);
-        const forceVision = this.routeHasForceFlag('vision');
+        const forceVision = selection.routeUsed === 'vision' && this.routeHasForceFlag('vision');
         const target = {
             ...baseTarget,
             ...(this.webSearchForce ? { forceWebSearch: true } : {}),
             ...(forceVision ? { forceVision: true } : {})
         };
+        const instructionProcessMode = this.resolveInstructionProcessModeForSelection(selection.providerKey, routingState);
+        if (instructionProcessMode) {
+            target.processMode = instructionProcessMode;
+        }
         recordAntigravitySessionLease({
             metadata: features.metadata,
             providerKey: selection.providerKey,
@@ -585,6 +820,20 @@ export class VirtualRouterEngine {
         };
     }
     getStopMessageState(metadata) {
+        const hasArmedStopState = (candidate) => {
+            if (!candidate) {
+                return false;
+            }
+            const text = typeof candidate.stopMessageText === 'string' ? candidate.stopMessageText.trim() : '';
+            const maxRepeats = typeof candidate.stopMessageMaxRepeats === 'number' && Number.isFinite(candidate.stopMessageMaxRepeats)
+                ? Math.max(1, Math.floor(candidate.stopMessageMaxRepeats))
+                : 0;
+            const mode = typeof candidate.stopMessageStageMode === 'string'
+                ? candidate.stopMessageStageMode.trim().toLowerCase()
+                : '';
+            const allowModeOnly = !text && maxRepeats > 0 && (mode === 'on' || mode === 'auto');
+            return (Boolean(text) || allowModeOnly) && maxRepeats > 0;
+        };
         const sessionScope = this.resolveSessionScope(metadata);
         const sessionState = sessionScope
             ? getRoutingInstructionState(sessionScope, this.routingInstructionState, this.routingStateStore)
@@ -593,9 +842,11 @@ export class VirtualRouterEngine {
         const stickyState = stickyKey
             ? getRoutingInstructionState(stickyKey, this.routingInstructionState, this.routingStateStore)
             : null;
-        const effectiveState = sessionState && typeof sessionState.stopMessageText === 'string' && sessionState.stopMessageText.trim()
+        const effectiveState = hasArmedStopState(sessionState)
             ? sessionState
-            : stickyState;
+            : hasArmedStopState(stickyState)
+                ? stickyState
+                : null;
         if (!effectiveState) {
             return null;
         }
@@ -604,11 +855,18 @@ export class VirtualRouterEngine {
             Number.isFinite(effectiveState.stopMessageMaxRepeats)
             ? Math.max(1, Math.floor(effectiveState.stopMessageMaxRepeats))
             : 0;
-        if (!text || maxRepeats <= 0) {
+        const stageModeRaw = typeof effectiveState.stopMessageStageMode === 'string'
+            ? effectiveState.stopMessageStageMode.trim().toLowerCase()
+            : '';
+        const stageModeNormalized = stageModeRaw === 'on' || stageModeRaw === 'off' || stageModeRaw === 'auto'
+            ? stageModeRaw
+            : undefined;
+        const allowModeOnly = !text && maxRepeats > 0 && (stageModeNormalized === 'on' || stageModeNormalized === 'auto');
+        if ((!text && !allowModeOnly) || maxRepeats <= 0) {
             return null;
         }
         return {
-            stopMessageText: text,
+            ...(text ? { stopMessageText: text } : {}),
             stopMessageMaxRepeats: maxRepeats,
             ...(typeof effectiveState.stopMessageSource === 'string' && effectiveState.stopMessageSource.trim()
                 ? { stopMessageSource: effectiveState.stopMessageSource.trim() }
@@ -623,6 +881,49 @@ export class VirtualRouterEngine {
             ...(typeof effectiveState.stopMessageLastUsedAt === 'number' &&
                 Number.isFinite(effectiveState.stopMessageLastUsedAt)
                 ? { stopMessageLastUsedAt: effectiveState.stopMessageLastUsedAt }
+                : {}),
+            ...(typeof effectiveState.stopMessageStage === 'string' && effectiveState.stopMessageStage.trim()
+                ? { stopMessageStage: effectiveState.stopMessageStage.trim() }
+                : {}),
+            ...(stageModeNormalized ? { stopMessageStageMode: stageModeNormalized } : {}),
+            ...(typeof effectiveState.stopMessageObservationHash === 'string' && effectiveState.stopMessageObservationHash.trim()
+                ? { stopMessageObservationHash: effectiveState.stopMessageObservationHash.trim() }
+                : {}),
+            ...(typeof effectiveState.stopMessageObservationStableCount === 'number' &&
+                Number.isFinite(effectiveState.stopMessageObservationStableCount)
+                ? { stopMessageObservationStableCount: Math.max(0, Math.floor(effectiveState.stopMessageObservationStableCount)) }
+                : {}),
+            ...(typeof effectiveState.stopMessageBdWorkState === 'string' && effectiveState.stopMessageBdWorkState.trim()
+                ? { stopMessageBdWorkState: effectiveState.stopMessageBdWorkState.trim() }
+                : {})
+        };
+    }
+    getPreCommandState(metadata) {
+        const sessionScope = this.resolveSessionScope(metadata);
+        const sessionState = sessionScope
+            ? getRoutingInstructionState(sessionScope, this.routingInstructionState, this.routingStateStore)
+            : null;
+        const stickyKey = this.resolveStickyKey(metadata);
+        const stickyState = stickyKey
+            ? getRoutingInstructionState(stickyKey, this.routingInstructionState, this.routingStateStore)
+            : null;
+        const effectiveState = sessionState && typeof sessionState.preCommandScriptPath === 'string' && sessionState.preCommandScriptPath.trim()
+            ? sessionState
+            : stickyState;
+        if (!effectiveState) {
+            return null;
+        }
+        const scriptPath = typeof effectiveState.preCommandScriptPath === 'string' ? effectiveState.preCommandScriptPath.trim() : '';
+        if (!scriptPath) {
+            return null;
+        }
+        return {
+            preCommandScriptPath: scriptPath,
+            ...(typeof effectiveState.preCommandSource === 'string' && effectiveState.preCommandSource.trim()
+                ? { preCommandSource: effectiveState.preCommandSource.trim() }
+                : {}),
+            ...(typeof effectiveState.preCommandUpdatedAt === 'number' && Number.isFinite(effectiveState.preCommandUpdatedAt)
+                ? { preCommandUpdatedAt: effectiveState.preCommandUpdatedAt }
                 : {})
         };
     }
@@ -787,6 +1088,27 @@ export class VirtualRouterEngine {
     resolveSessionScope(metadata) {
         return resolveSessionScopeImpl(metadata);
     }
+    resolveInstructionProcessModeForSelection(providerKey, routingState) {
+        const candidates = [
+            routingState.forcedTarget,
+            routingState.stickyTarget,
+            routingState.preferTarget
+        ];
+        for (const candidate of candidates) {
+            const processMode = candidate?.processMode;
+            if (!processMode) {
+                continue;
+            }
+            const resolved = this.resolveInstructionTarget(candidate);
+            if (!resolved) {
+                continue;
+            }
+            if (resolved.keys.includes(providerKey)) {
+                return processMode;
+            }
+        }
+        return undefined;
+    }
     resolveInstructionTarget(target) {
         if (!target || !target.provider) {
             return null;
@@ -1034,6 +1356,8 @@ export class VirtualRouterEngine {
     }
     buildRouteCandidates(requestedRoute, classificationCandidates, features) {
         const forceVision = this.routeHasForceFlag('vision');
+        const hasMultimodalTargets = this.routeHasTargets(this.routing.multimodal);
+        const hasVisionTargets = this.routeHasTargets(this.routing.vision);
         const normalized = this.normalizeRouteAlias(requestedRoute || DEFAULT_ROUTE);
         const baseList = [];
         if (classificationCandidates && classificationCandidates.length) {
@@ -1044,35 +1368,31 @@ export class VirtualRouterEngine {
         else if (normalized) {
             baseList.push(normalized);
         }
-        // 当检测到当前请求包含图片时，确保 default/thinking 也参与候选集，
-        // 以便优先尝试内建多模态模型（Responses/Gemini），再回落到 vision 路由池。
-        if (features.hasImageAttachment && !forceVision) {
-            const visionAwareRoutes = [DEFAULT_ROUTE, 'thinking'];
-            for (const routeName of visionAwareRoutes) {
-                if (this.routeHasTargets(this.routing[routeName]) && !baseList.includes(routeName)) {
-                    baseList.push(routeName);
-                }
-            }
-        }
         if (features.hasImageAttachment) {
-            const allRouteNames = Object.keys(this.routing);
-            for (const routeName of allRouteNames) {
-                if (!this.routeHasTargets(this.routing[routeName])) {
-                    continue;
+            if (hasMultimodalTargets) {
+                if (!baseList.includes('multimodal')) {
+                    baseList.unshift('multimodal');
                 }
-                if (!this.routeSupportsModel(routeName, 'kimi-k2.5')) {
-                    continue;
+            }
+            else if (hasVisionTargets) {
+                if (!baseList.includes('vision')) {
+                    baseList.unshift('vision');
                 }
-                if (!baseList.includes(routeName)) {
-                    baseList.push(routeName);
+            }
+            if (!forceVision && hasMultimodalTargets) {
+                const visionAwareRoutes = [DEFAULT_ROUTE, 'thinking'];
+                for (const routeName of visionAwareRoutes) {
+                    if (this.routeHasTargets(this.routing[routeName]) && !baseList.includes(routeName)) {
+                        baseList.push(routeName);
+                    }
                 }
             }
         }
         let ordered = this.sortByPriority(baseList);
-        if (features.hasImageAttachment && !forceVision) {
+        if (features.hasImageAttachment && !forceVision && hasMultimodalTargets) {
             ordered = this.reorderForInlineVision(ordered);
         }
-        if (features.hasImageAttachment) {
+        if (features.hasImageAttachment && hasMultimodalTargets) {
             ordered = this.reorderForPreferredModel(ordered, 'kimi-k2.5');
         }
         const deduped = [];

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

@@ -1,6 +1,6 @@
 import { detectExtendedThinkingKeyword, detectImageAttachment, detectKeyword, extractMessageText, getLatestMessageRole, getLatestUserMessage } from './message-utils.js';
 import { extractAntigravityGeminiSessionId } from '../../conversion/compat/antigravity-session-signature.js';
-import { detectCodingTool, detectLastAssistantToolCategory, detectVisionTool, detectWebTool, extractMeaningfulDeclaredToolNames } from './tool-signals.js';
+import { 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'];
 export function buildRoutingFeatures(request, metadata) {
@@ -59,6 +59,7 @@ export function buildRoutingFeatures(request, metadata) {
         hasVisionTool,
         hasImageAttachment,
         hasWebTool,
+        hasWebSearchToolDeclared: detectWebSearchToolDeclared(request),
         hasCodingTool,
         hasThinkingKeyword,
         estimatedTokens,

package/dist/router/virtual-router/pre-command-file-resolver.d.ts

@@ -0,0 +1,2 @@
+export declare function resolvePreCommandScriptPath(raw: string): string;
+export declare function isPreCommandScriptPathAllowed(rawPath: string): boolean;