@jsonstudio/llms 0.6.2172 → 0.6.3214

package/dist/quota/quota-manager.js

@@ -115,16 +115,6 @@ function collectUpstreamErrorSources(ev) {
 function isAntigravityProviderKey(providerKey) {
     return providerKey.toLowerCase().startsWith('antigravity.');
 }
-function resolveAntigravityRuntimeKey(providerKey, ev) {
-    const rtKey = safeTrim(ev?.runtime?.target?.runtimeKey);
-    if (rtKey)
-        return rtKey;
-    const parts = providerKey.split('.').filter(Boolean);
-    if (parts.length >= 2) {
-        return `${parts[0]}.${parts[1]}`;
-    }
-    return null;
-}
 function isGoogleAccountVerificationRequired(ev, sources) {
     if (!sources.length) {
         sources = collectUpstreamErrorSources(ev);
@@ -277,64 +267,46 @@ export class QuotaManager {
         const code = safeTrim(ev.code) || safeTrim(ev?.runtime?.errorCode);
         const details = ev.details && typeof ev.details === 'object' ? ev.details : undefined;
         const state = this.ensureProvider(providerKey);
-        // Antigravity account-scope auth verification required: blacklist the whole runtimeKey group.
+        // Antigravity account-scope auth verification required: isolate to current providerKey only.
         if (isAntigravityProviderKey(providerKey)) {
             const sources = collectUpstreamErrorSources(ev);
-            const runtimeKey = resolveAntigravityRuntimeKey(providerKey, ev);
-            if (runtimeKey && isGoogleAccountVerificationRequired(ev, sources)) {
+            if (isGoogleAccountVerificationRequired(ev, sources)) {
                 const url = extractFirstUrl(sources);
                 const banUntil = nowMs + ANTIGRAVITY_AUTH_VERIFY_BAN_MS;
-                for (const key of this.states.keys()) {
-                    if (!key.startsWith(`${runtimeKey}.`))
-                        continue;
-                    const s = this.ensureProvider(key);
-                    const next = {
-                        ...s,
-                        inPool: false,
-                        reason: 'authVerify',
-                        authIssue: {
-                            kind: 'google_account_verification',
-                            ...(url ? { url } : {}),
-                            message: 'account verification required'
-                        },
-                        blacklistUntil: Math.max(s.blacklistUntil ?? 0, banUntil) || banUntil,
-                        cooldownUntil: null,
-                        lastErrorAtMs: nowMs,
-                        lastErrorCode: code || 'AUTH_VERIFY',
-                        lastErrorSeries: 'EFATAL',
-                        consecutiveErrorCount: 0
-                    };
-                    this.states.set(key, tickQuotaStateTime(next, nowMs));
-                }
+                const next = {
+                    ...state,
+                    inPool: false,
+                    reason: 'authVerify',
+                    authIssue: {
+                        kind: 'google_account_verification',
+                        ...(url ? { url } : {}),
+                        message: 'account verification required'
+                    },
+                    blacklistUntil: Math.max(state.blacklistUntil ?? 0, banUntil) || banUntil,
+                    cooldownUntil: null,
+                    lastErrorAtMs: nowMs,
+                    lastErrorCode: code || 'AUTH_VERIFY',
+                    lastErrorSeries: 'EFATAL',
+                    consecutiveErrorCount: 0
+                };
+                this.states.set(providerKey, tickQuotaStateTime(next, nowMs));
                 this.markDirty();
                 return;
             }
-            // Thought signature missing: freeze Gemini series under runtimeKey to avoid request storms.
+            // Thought signature missing: cooldown current providerKey only.
             if (isThoughtSignatureMissing(ev, sources)) {
                 const freezeUntil = nowMs + ANTIGRAVITY_THOUGHT_SIGNATURE_MISSING_COOLDOWN_MS;
-                const prefix = runtimeKey ? `${runtimeKey}.` : `${providerKey.split('.').slice(0, 2).join('.')}.`;
-                for (const key of this.states.keys()) {
-                    if (!key.startsWith(prefix))
-                        continue;
-                    const parts = key.split('.');
-                    const modelId = parts.length >= 3 ? parts.slice(2).join('.') : '';
-                    const lowerModel = modelId.toLowerCase();
-                    const isGeminiSeries = lowerModel.includes('gemini') && (lowerModel.includes('pro') || lowerModel.includes('flash'));
-                    if (!isGeminiSeries)
-                        continue;
-                    const s = this.ensureProvider(key);
-                    const next = {
-                        ...s,
-                        inPool: false,
-                        reason: 'cooldown',
-                        cooldownUntil: Math.max(s.cooldownUntil ?? 0, freezeUntil) || freezeUntil,
-                        lastErrorAtMs: nowMs,
-                        lastErrorCode: code || 'SIGNATURE_MISSING',
-                        lastErrorSeries: 'EOTHER',
-                        consecutiveErrorCount: 0
-                    };
-                    this.states.set(key, tickQuotaStateTime(next, nowMs));
-                }
+                const next = {
+                    ...state,
+                    inPool: false,
+                    reason: 'cooldown',
+                    cooldownUntil: Math.max(state.cooldownUntil ?? 0, freezeUntil) || freezeUntil,
+                    lastErrorAtMs: nowMs,
+                    lastErrorCode: code || 'SIGNATURE_MISSING',
+                    lastErrorSeries: 'EOTHER',
+                    consecutiveErrorCount: 0
+                };
+                this.states.set(providerKey, tickQuotaStateTime(next, nowMs));
                 this.markDirty();
                 return;
             }

package/dist/quota/quota-state.js

@@ -1,6 +1,6 @@
-const COOLDOWN_SCHEDULE_429_MS = [5_000, 30_000, 60_000, 300_000, 1_800_000, 3_600_000, 10_000_000];
-const COOLDOWN_SCHEDULE_FATAL_MS = [5 * 60_000, 15 * 60_000, 30 * 60_000, 60 * 60_000, 3 * 60 * 60_000];
-const COOLDOWN_SCHEDULE_DEFAULT_MS = [5_000, 30_000, 60_000, 300_000, 1_800_000, 3_600_000, 10_000_000];
+const COOLDOWN_SCHEDULE_429_MS = [3_000, 10_000, 31_000, 61_000];
+const COOLDOWN_SCHEDULE_FATAL_MS = [3_000, 10_000, 31_000, 61_000];
+const COOLDOWN_SCHEDULE_DEFAULT_MS = [3_000, 10_000, 31_000, 61_000];
 const ERROR_CHAIN_WINDOW_MS = 10 * 60_000;
 const NETWORK_ERROR_CODES = [
     'ECONNRESET',
@@ -56,14 +56,21 @@ export function normalizeErrorSeries(event) {
 }
 function normalizeErrorKey(event) {
     const rawCode = String(event.code || '').trim().toUpperCase();
-    if (rawCode) {
+    const status = typeof event.httpStatus === 'number' ? event.httpStatus : null;
+    const isGenericCode = rawCode === '' ||
+        rawCode === 'ERR_PROVIDER_FAILURE' ||
+        rawCode === 'ERR_PIPELINE_FAILURE' ||
+        rawCode === 'ERR_COMPATIBILITY' ||
+        rawCode === 'EXTERNAL_ERROR' ||
+        rawCode === 'INTERNAL_ERROR' ||
+        rawCode === 'TOOL_ERROR';
+    if (!isGenericCode) {
         return rawCode;
     }
-    const status = typeof event.httpStatus === 'number' ? event.httpStatus : null;
     if (status && Number.isFinite(status)) {
         return `HTTP_${Math.floor(status)}`;
     }
-    return 'ERR_UNKNOWN';
+    return rawCode || 'ERR_UNKNOWN';
 }
 function computeCooldownMsBySeries(series, consecutive) {
     if (consecutive <= 0) {
@@ -125,12 +132,12 @@ export function applyErrorEvent(state, event, nowMs = event.timestampMs ?? Date.
         nowMs - lastAt >= 0 &&
         nowMs - lastAt <= ERROR_CHAIN_WINDOW_MS;
     const sameErrorKey = withinChainWindow && state.lastErrorCode === errorKey;
-    const rawNextCount = sameErrorKey ? state.consecutiveErrorCount + 1 : 1;
     const schedule = series === 'E429'
         ? COOLDOWN_SCHEDULE_429_MS
         : series === 'EFATAL'
             ? COOLDOWN_SCHEDULE_FATAL_MS
             : COOLDOWN_SCHEDULE_DEFAULT_MS;
+    const rawNextCount = sameErrorKey ? state.consecutiveErrorCount + 1 : 1;
     const nextCount = rawNextCount > schedule.length ? 1 : rawNextCount;
     const cooldownMs = computeCooldownMsBySeries(series, nextCount);
     const nextUntil = cooldownMs ? nowMs + cooldownMs : null;

package/dist/router/virtual-router/bootstrap/profile-builder.d.ts

@@ -4,4 +4,5 @@ export declare function buildProviderProfiles(targetKeys: Set<string>, runtimeEn
     targetRuntime: Record<string, ProviderRuntimeProfile>;
 };
 export declare function resolveContextTokens(runtime: ProviderRuntimeProfile, modelId: string): number;
+export declare function resolveOutputTokens(runtime: ProviderRuntimeProfile, modelId: string): number | undefined;
 export declare function normalizeHealth(input: unknown): ProviderHealthConfig | undefined;

package/dist/router/virtual-router/bootstrap/profile-builder.js

@@ -16,6 +16,7 @@ export function buildProviderProfiles(targetKeys, runtimeEntries) {
             ? runtime.modelStreaming?.[parsed.modelId]
             : runtime.streaming;
         const contextTokens = resolveContextTokens(runtime, parsed.modelId);
+        const outputTokens = resolveOutputTokens(runtime, parsed.modelId);
         profiles[targetKey] = {
             providerKey: targetKey,
             providerType: runtime.providerType,
@@ -28,6 +29,7 @@ export function buildProviderProfiles(targetKeys, runtimeEntries) {
             processMode: runtime.processMode || 'chat',
             responsesConfig: runtime.responsesConfig,
             streaming: streamingPref,
+            maxOutputTokens: outputTokens,
             maxContextTokens: contextTokens,
             ...(runtime.deepseek ? { deepseek: runtime.deepseek } : {}),
             ...(runtime.serverToolsDisabled ? { serverToolsDisabled: true } : {})
@@ -52,6 +54,17 @@ export function resolveContextTokens(runtime, modelId) {
     }
     return DEFAULT_MODEL_CONTEXT_TOKENS;
 }
+export function resolveOutputTokens(runtime, modelId) {
+    const specific = runtime.modelOutputTokens?.[modelId];
+    if (typeof specific === 'number' && Number.isFinite(specific) && specific > 0) {
+        return Math.floor(specific);
+    }
+    const fallback = runtime.defaultOutputTokens;
+    if (typeof fallback === 'number' && Number.isFinite(fallback) && fallback > 0) {
+        return Math.floor(fallback);
+    }
+    return undefined;
+}
 export function normalizeHealth(input) {
     if (!input || typeof input !== 'object')
         return undefined;

package/dist/router/virtual-router/bootstrap/provider-normalization.d.ts

@@ -18,6 +18,8 @@ export interface NormalizedProvider {
     responsesConfig?: ResponsesProviderConfig;
     streaming?: 'always' | 'auto' | 'never';
     modelStreaming?: Record<string, 'always' | 'auto' | 'never'>;
+    modelOutputTokens?: Record<string, number>;
+    defaultOutputTokens?: number;
     modelContextTokens?: Record<string, number>;
     defaultContextTokens?: number;
     deepseek?: DeepSeekCompatRuntimeOptions;

package/dist/router/virtual-router/bootstrap/provider-normalization.js

@@ -5,7 +5,7 @@
 import { VirtualRouterError, VirtualRouterErrorCode } from '../types.js';
 import { CLAUDE_CODE_DEFAULT_USER_AGENT, CLAUDE_CODE_DEFAULT_X_APP, CLAUDE_CODE_DEFAULT_ANTHROPIC_BETA, parseClaudeCodeAppVersionFromUserAgent } from './claude-code-helpers.js';
 import { normalizeResponsesConfig, resolveProviderStreamingPreference } from './responses-helpers.js';
-import { normalizeModelStreaming, normalizeModelContextTokens } from './streaming-helpers.js';
+import { normalizeModelStreaming, normalizeModelContextTokens, normalizeModelOutputTokens } from './streaming-helpers.js';
 /**
  * Normalize a raw provider configuration into a NormalizedProvider.
  */
@@ -33,6 +33,7 @@ export function normalizeProvider(providerId, raw) {
     const streaming = resolveProviderStreamingPreference(provider, responsesNode);
     const modelStreaming = normalizeModelStreaming(provider);
     const { modelContextTokens, defaultContextTokens } = normalizeModelContextTokens(provider);
+    const { modelOutputTokens, defaultOutputTokens } = normalizeModelOutputTokens(provider);
     const deepseek = normalizeDeepSeekOptions(provider);
     const serverToolsDisabled = provider.serverToolsDisabled === true ||
         (typeof provider.serverToolsDisabled === 'string' &&
@@ -51,6 +52,8 @@ export function normalizeProvider(providerId, raw) {
         responsesConfig,
         streaming,
         modelStreaming,
+        modelOutputTokens,
+        defaultOutputTokens,
         modelContextTokens,
         defaultContextTokens,
         ...(deepseek ? { deepseek } : {}),

package/dist/router/virtual-router/bootstrap/streaming-helpers.d.ts

@@ -10,3 +10,10 @@ export declare function normalizeModelContextTokens(provider: Record<string, unk
     modelContextTokens?: Record<string, number>;
     defaultContextTokens?: number;
 };
+/**
+ * Normalize model-level output token limits (maxTokens / max_output_tokens).
+ */
+export declare function normalizeModelOutputTokens(provider: Record<string, unknown>): {
+    modelOutputTokens?: Record<string, number>;
+    defaultOutputTokens?: number;
+};

package/dist/router/virtual-router/bootstrap/streaming-helpers.js

@@ -83,6 +83,29 @@ export function normalizeModelContextTokens(provider) {
         defaultContextTokens: defaultCandidate
     };
 }
+/**
+ * Normalize model-level output token limits (maxTokens / max_output_tokens).
+ */
+export function normalizeModelOutputTokens(provider) {
+    const modelsNode = asRecord(provider.models);
+    const normalized = {};
+    for (const [modelId, modelRaw] of Object.entries(modelsNode)) {
+        if (!modelRaw || typeof modelRaw !== 'object') {
+            continue;
+        }
+        const candidate = readOutputTokens(modelRaw);
+        if (candidate) {
+            normalized[modelId] = candidate;
+        }
+    }
+    const configNode = asRecord(provider.config);
+    const defaultsNode = asRecord(configNode?.userConfigDefaults);
+    const defaultCandidate = readOutputTokens(provider) ?? readOutputTokens(configNode) ?? readOutputTokens(defaultsNode);
+    return {
+        modelOutputTokens: Object.keys(normalized).length ? normalized : undefined,
+        defaultOutputTokens: defaultCandidate
+    };
+}
 /**
  * Read context tokens from various field names.
  */
@@ -107,6 +130,27 @@ function readContextTokens(record) {
     }
     return undefined;
 }
+function readOutputTokens(record) {
+    if (!record) {
+        return undefined;
+    }
+    const keys = [
+        'maxOutputTokens',
+        'max_output_tokens',
+        'maxTokens',
+        'max_tokens',
+        'outputTokens',
+        'output_tokens'
+    ];
+    for (const key of keys) {
+        const value = record[key];
+        const parsed = normalizePositiveInteger(value);
+        if (parsed) {
+            return parsed;
+        }
+    }
+    return undefined;
+}
 /**
  * Normalize positive integer value.
  */

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

@@ -129,6 +129,8 @@ function buildProviderRuntimeEntries(providers) {
                 responsesConfig: normalizedProvider.responsesConfig,
                 streaming: normalizedProvider.streaming,
                 modelStreaming: normalizedProvider.modelStreaming,
+                modelOutputTokens: normalizedProvider.modelOutputTokens,
+                defaultOutputTokens: normalizedProvider.defaultOutputTokens,
                 modelContextTokens: normalizedProvider.modelContextTokens,
                 defaultContextTokens: normalizedProvider.defaultContextTokens,
                 ...(normalizedProvider.deepseek ? { deepseek: normalizedProvider.deepseek } : {}),

package/dist/router/virtual-router/engine/provider-key/parse.d.ts

@@ -1,6 +1 @@
-import type { ProviderRegistry } from '../../provider-registry.js';
-export declare function extractProviderId(providerKey: string): string | null;
-export declare function normalizeAliasDescriptor(alias: string): string;
-export declare function extractKeyAlias(providerKey: string): string | null;
-export declare function extractKeyIndex(providerKey: string): number | undefined;
-export declare function getProviderModelId(providerKey: string, providerRegistry: ProviderRegistry): string | null;
+export { extractProviderId, normalizeAliasDescriptor, extractKeyAlias, extractKeyIndex, getProviderModelId } from '../../engine-selection/key-parsing.js';

package/dist/router/virtual-router/engine/provider-key/parse.js

@@ -1,43 +1 @@
-export function extractProviderId(providerKey) {
-    const firstDot = providerKey.indexOf('.');
-    if (firstDot <= 0)
-        return null;
-    return providerKey.substring(0, firstDot);
-}
-export function normalizeAliasDescriptor(alias) {
-    if (/^\d+-/.test(alias)) {
-        return alias.replace(/^\d+-/, '');
-    }
-    return alias;
-}
-export function extractKeyAlias(providerKey) {
-    const parts = providerKey.split('.');
-    if (parts.length === 3) {
-        return normalizeAliasDescriptor(parts[1]);
-    }
-    return null;
-}
-export function extractKeyIndex(providerKey) {
-    const parts = providerKey.split('.');
-    if (parts.length === 2) {
-        const index = parseInt(parts[1], 10);
-        if (!isNaN(index) && index > 0) {
-            return index;
-        }
-    }
-    return undefined;
-}
-export function getProviderModelId(providerKey, providerRegistry) {
-    const profile = providerRegistry.get(providerKey);
-    if (profile.modelId) {
-        return profile.modelId;
-    }
-    const parts = providerKey.split('.');
-    if (parts.length === 2) {
-        return parts[1] || null;
-    }
-    if (parts.length === 3) {
-        return parts[2] || null;
-    }
-    return null;
-}
+export { extractProviderId, normalizeAliasDescriptor, extractKeyAlias, extractKeyIndex, getProviderModelId } from '../../engine-selection/key-parsing.js';

package/dist/router/virtual-router/engine/routing-state/store.d.ts

@@ -1,6 +1,6 @@
 import type { RouterMetadataInput } from '../../types.js';
 import type { RoutingInstructionState } from '../../routing-instructions.js';
-type RoutingInstructionStateStoreLike = {
+export type RoutingInstructionStateStoreLike = {
     loadSync: (key: string) => RoutingInstructionState | null;
     saveAsync: (key: string, state: RoutingInstructionState | null) => void;
     saveSync?: (key: string, state: RoutingInstructionState | null) => void;
@@ -8,4 +8,3 @@ type RoutingInstructionStateStoreLike = {
 export declare function resolveStopMessageScope(metadata: RouterMetadataInput): string | undefined;
 export declare function getRoutingInstructionState(stickyKey: string | undefined, routingInstructionState: Map<string, RoutingInstructionState>, routingStateStore: RoutingInstructionStateStoreLike): RoutingInstructionState;
 export declare function persistRoutingInstructionState(key: string, state: RoutingInstructionState, routingStateStore: RoutingInstructionStateStoreLike): void;
-export {};

package/dist/router/virtual-router/engine/routing-state/store.js

@@ -1,18 +1,41 @@
 import { mergeStopMessageFromPersisted } from '../../stop-message-state-sync.js';
+function readToken(value) {
+    if (typeof value !== 'string') {
+        return '';
+    }
+    const trimmed = value.trim();
+    return trimmed || '';
+}
+function isPersistentScopeKey(key) {
+    if (!key) {
+        return false;
+    }
+    return key.startsWith('session:')
+        || key.startsWith('conversation:')
+        || key.startsWith('tmux:');
+}
 export function resolveStopMessageScope(metadata) {
-    const sessionId = typeof metadata?.sessionId === 'string' ? String(metadata.sessionId).trim() : '';
-    if (sessionId) {
-        return `session:${sessionId}`;
+    const explicitScope = readToken(metadata?.stopMessageClientInjectSessionScope)
+        || readToken(metadata?.stopMessageClientInjectScope);
+    if (explicitScope && explicitScope.startsWith('tmux:')) {
+        return explicitScope;
+    }
+    const tmuxSessionId = readToken(metadata?.clientTmuxSessionId)
+        || readToken(metadata?.client_tmux_session_id)
+        || readToken(metadata?.tmuxSessionId)
+        || readToken(metadata?.tmux_session_id);
+    if (tmuxSessionId) {
+        return `tmux:${tmuxSessionId}`;
     }
     return undefined;
 }
 export function getRoutingInstructionState(stickyKey, routingInstructionState, routingStateStore) {
     const key = stickyKey || 'default';
     const existing = routingInstructionState.get(key);
-    // 对 session:/conversation: 作用域，在每次读取时尝试从磁盘刷新 stopMessage 相关字段，
+    // 对 session:/conversation:/tmux: 作用域，在每次读取时尝试从磁盘刷新 stopMessage 相关字段，
     // 确保 servertool（如 stop_message_auto）通过 sticky-session-store 更新的使用次数
     // 能在 VirtualRouter 日志中实时反映出来。
-    if (existing && (key.startsWith('session:') || key.startsWith('conversation:'))) {
+    if (existing && isPersistentScopeKey(key)) {
         try {
             const persisted = routingStateStore.loadSync(key);
             const merged = mergeStopMessageFromPersisted(existing, persisted);
@@ -22,6 +45,10 @@ export function getRoutingInstructionState(stickyKey, routingInstructionState, r
             existing.stopMessageUsed = merged.stopMessageUsed;
             existing.stopMessageUpdatedAt = merged.stopMessageUpdatedAt;
             existing.stopMessageLastUsedAt = merged.stopMessageLastUsedAt;
+            existing.stopMessageStageMode = merged.stopMessageStageMode;
+            existing.stopMessageAiMode = merged.stopMessageAiMode;
+            existing.stopMessageAiSeedPrompt = merged.stopMessageAiSeedPrompt;
+            existing.stopMessageAiHistory = merged.stopMessageAiHistory;
             if (persisted) {
                 existing.preCommandSource = persisted.preCommandSource;
                 existing.preCommandScriptPath = persisted.preCommandScriptPath;
@@ -34,8 +61,8 @@ export function getRoutingInstructionState(stickyKey, routingInstructionState, r
         return existing;
     }
     let initial = null;
-    // 仅对 session:/conversation: 作用域的 key 尝试从磁盘恢复持久化状态
-    if (key.startsWith('session:') || key.startsWith('conversation:')) {
+    // 仅对 session:/conversation:/tmux: 作用域的 key 尝试从磁盘恢复持久化状态
+    if (isPersistentScopeKey(key)) {
         initial = routingStateStore.loadSync(key);
     }
     if (!initial) {
@@ -52,6 +79,10 @@ export function getRoutingInstructionState(stickyKey, routingInstructionState, r
             stopMessageUsed: undefined,
             stopMessageUpdatedAt: undefined,
             stopMessageLastUsedAt: undefined,
+            stopMessageStageMode: undefined,
+            stopMessageAiMode: undefined,
+            stopMessageAiSeedPrompt: undefined,
+            stopMessageAiHistory: undefined,
             preCommandSource: undefined,
             preCommandScriptPath: undefined,
             preCommandUpdatedAt: undefined
@@ -74,8 +105,8 @@ function isRoutingStateEmpty(state) {
     const noStopMessage = (!state.stopMessageText || !state.stopMessageText.trim()) &&
         (typeof state.stopMessageMaxRepeats !== 'number' || !Number.isFinite(state.stopMessageMaxRepeats)) &&
         (typeof state.stopMessageUsed !== 'number' || !Number.isFinite(state.stopMessageUsed)) &&
-        (typeof state.stopMessageUpdatedAt !== 'number' || !Number.isFinite(state.stopMessageUpdatedAt)) &&
-        (typeof state.stopMessageLastUsedAt !== 'number' || !Number.isFinite(state.stopMessageLastUsedAt));
+        (typeof state.stopMessageStageMode !== 'string' || !state.stopMessageStageMode.trim()) &&
+        (typeof state.stopMessageAiMode !== 'string' || !state.stopMessageAiMode.trim());
     const noPreCommand = (!state.preCommandScriptPath || !state.preCommandScriptPath.trim()) &&
         (typeof state.preCommandUpdatedAt !== 'number' || !Number.isFinite(state.preCommandUpdatedAt));
     return (noForced &&
@@ -89,21 +120,26 @@ function isRoutingStateEmpty(state) {
         noPreCommand);
 }
 export function persistRoutingInstructionState(key, state, routingStateStore) {
-    if (!key || (!key.startsWith('session:') && !key.startsWith('conversation:'))) {
+    if (!isPersistentScopeKey(key)) {
         return;
     }
     const supportsSync = typeof routingStateStore.saveSync === 'function';
+    const shouldUseSyncForSession = supportsSync && (key.startsWith('session:')
+        || key.startsWith('tmux:'));
     const prefersSync = supportsSync &&
-        key.startsWith('session:') &&
+        (key.startsWith('session:')
+            || key.startsWith('tmux:')) &&
         (Boolean(state.stopMessageText && state.stopMessageText.trim()) ||
             (typeof state.stopMessageMaxRepeats === 'number' && Number.isFinite(state.stopMessageMaxRepeats)) ||
             (typeof state.stopMessageUsed === 'number' && Number.isFinite(state.stopMessageUsed)) ||
-            (typeof state.stopMessageUpdatedAt === 'number' && Number.isFinite(state.stopMessageUpdatedAt)) ||
-            (typeof state.stopMessageLastUsedAt === 'number' && Number.isFinite(state.stopMessageLastUsedAt)) ||
+            Boolean(state.stopMessageStageMode && state.stopMessageStageMode.trim()) ||
+            Boolean(state.stopMessageAiMode && state.stopMessageAiMode.trim()) ||
             Boolean(state.preCommandScriptPath && state.preCommandScriptPath.trim()) ||
             (typeof state.preCommandUpdatedAt === 'number' && Number.isFinite(state.preCommandUpdatedAt)));
     if (isRoutingStateEmpty(state)) {
-        if (prefersSync) {
+        // For session scope, clear must be sync to avoid stale persisted snapshots
+        // being reloaded immediately by same-request readers.
+        if (shouldUseSyncForSession) {
             routingStateStore.saveSync(key, null);
         }
         else {

package/dist/router/virtual-router/engine-legacy/config.d.ts

@@ -0,0 +1,11 @@
+import type { ProviderQuotaView } from '../types.js';
+import type { VirtualRouterConfig, VirtualRouterHealthStore } from '../types.js';
+import type { RoutingInstructionStateStoreLike } from '../engine/routing-state/store.js';
+import type { VirtualRouterEngine } from '../engine-legacy.js';
+export declare function updateDeps(engine: VirtualRouterEngine, deps: {
+    healthStore?: VirtualRouterHealthStore | null;
+    routingStateStore?: RoutingInstructionStateStoreLike | null;
+    quotaView?: ProviderQuotaView | null;
+}): void;
+export declare function initialize(engine: VirtualRouterEngine, config: VirtualRouterConfig): void;
+export declare function validateConfig(engine: VirtualRouterEngine, config: VirtualRouterConfig): void;

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

@@ -0,0 +1,108 @@
+import { RouteLoadBalancer } from '../load-balancer.js';
+import { StickySessionManager } from '../engine/sticky-session-manager.js';
+import { RoutingClassifier } from '../classifier.js';
+import { loadRoutingInstructionStateSync, saveRoutingInstructionStateAsync, saveRoutingInstructionStateSync } from '../sticky-session-store.js';
+import { resolveAntigravityAliasReuseCooldownMs, hydrateAntigravityAliasLeaseStoreIfNeeded } from '../engine/antigravity/alias-lease.js';
+import { routeHasTargets, hasPrimaryPool } from './route-utils.js';
+import { DEFAULT_ROUTE, VirtualRouterError, VirtualRouterErrorCode } from '../types.js';
+export function updateDeps(engine, deps) {
+    if (!deps || typeof deps !== 'object') {
+        return;
+    }
+    if ('healthStore' in deps) {
+        engine.healthStore = deps.healthStore ?? undefined;
+        engine.cooldownManager.updateDeps({ healthStore: engine.healthStore });
+    }
+    if ('routingStateStore' in deps) {
+        engine.routingStateStore =
+            deps.routingStateStore ??
+                {
+                    loadSync: loadRoutingInstructionStateSync,
+                    saveAsync: saveRoutingInstructionStateAsync,
+                    saveSync: saveRoutingInstructionStateSync
+                };
+        // Routing state store changes require clearing in-memory cache to avoid stale reads.
+        engine.routingInstructionState.clear();
+    }
+    if ('quotaView' in deps) {
+        const prevQuotaEnabled = Boolean(engine.quotaView);
+        engine.quotaView = deps.quotaView ?? undefined;
+        engine.cooldownManager.updateDeps({ quotaView: engine.quotaView });
+        const nextQuotaEnabled = Boolean(engine.quotaView);
+        // When quotaView is enabled, health/cooldown decisions must be driven by quotaView only.
+        // - Enabling quotaView: clear any legacy router-local cooldown TTLs immediately.
+        // - Disabling quotaView: reload legacy cooldown state from health snapshots.
+        if (!prevQuotaEnabled && nextQuotaEnabled) {
+            engine.cooldownManager.clearAllCooldowns();
+        }
+        else if (prevQuotaEnabled && !nextQuotaEnabled) {
+            engine.cooldownManager.clearAllCooldowns();
+            engine.restoreHealthFromStore();
+        }
+    }
+}
+export function initialize(engine, config) {
+    validateConfig(engine, config);
+    engine.routing = config.routing;
+    engine.providerRegistry.load(config.providers);
+    engine.healthManager.configure(config.health);
+    engine.healthConfig = config.health ?? null;
+    engine.healthManager.registerProviders(Object.keys(config.providers));
+    engine.cooldownManager.clearAllCooldowns();
+    engine.restoreHealthFromStore();
+    engine.loadBalancer = new RouteLoadBalancer(config.loadBalancing);
+    const aliasReuseCooldownMs = resolveAntigravityAliasReuseCooldownMs(config);
+    engine.stickySessionManager = new StickySessionManager(aliasReuseCooldownMs);
+    hydrateAntigravityAliasLeaseStoreIfNeeded({
+        force: true,
+        leaseStore: engine.stickySessionManager.getAllStores().aliasLeaseStore,
+        persistence: engine.antigravityLeasePersistence,
+        aliasReuseCooldownMs: engine.stickySessionManager.getAliasReuseCooldownMs()
+    });
+    engine.classifier = new RoutingClassifier(config.classifier);
+    engine.contextRouting = config.contextRouting ?? { warnRatio: 0.9, hardLimit: false };
+    engine.contextAdvisor.configure(engine.contextRouting);
+    engine.webSearchForce = config.webSearch?.force === true;
+    engine.routeAnalytics.getAllRouteStats().clear();
+    for (const routeName of Object.keys(engine.routing)) {
+        engine.routeAnalytics.getRouteStats(routeName) ||
+            engine.routeAnalytics.incrementRouteStat(routeName, '', {
+                timestampMs: Date.now(),
+                stopMessage: { active: false }
+            });
+    }
+}
+export function validateConfig(engine, config) {
+    if (!config.routing || typeof config.routing !== 'object') {
+        throw new VirtualRouterError('routing configuration is required', VirtualRouterErrorCode.CONFIG_ERROR);
+    }
+    if (!config.providers || Object.keys(config.providers).length === 0) {
+        throw new VirtualRouterError('providers configuration is required', VirtualRouterErrorCode.CONFIG_ERROR);
+    }
+    const defaultPools = config.routing[DEFAULT_ROUTE];
+    if (!routeHasTargets(engine, defaultPools)) {
+        throw new VirtualRouterError('default route must be configured with at least one provider', VirtualRouterErrorCode.CONFIG_ERROR);
+    }
+    if (!hasPrimaryPool(engine, defaultPools)) {
+        throw new VirtualRouterError('default route must define at least one non-backup pool', VirtualRouterErrorCode.CONFIG_ERROR);
+    }
+    const providerKeys = new Set(Object.keys(config.providers));
+    for (const [routeName, pools] of Object.entries(config.routing)) {
+        if (!routeHasTargets(engine, pools)) {
+            if (routeName === DEFAULT_ROUTE) {
+                throw new VirtualRouterError('default route cannot be empty', VirtualRouterErrorCode.CONFIG_ERROR);
+            }
+            continue;
+        }
+        for (const pool of pools) {
+            if (!Array.isArray(pool.targets) || !pool.targets.length) {
+                continue;
+            }
+            for (const providerKey of pool.targets) {
+                if (!providerKeys.has(providerKey)) {
+                    throw new VirtualRouterError(`Route ${routeName} references unknown provider ${providerKey}`, VirtualRouterErrorCode.CONFIG_ERROR);
+                }
+            }
+        }
+    }
+}

package/dist/router/virtual-router/engine-legacy/direct-model.d.ts

@@ -0,0 +1,10 @@
+import type { RoutingFeatures } from '../types.js';
+import type { VirtualRouterEngine } from '../engine-legacy.js';
+export declare function parseDirectProviderModel(engine: VirtualRouterEngine, model: string | undefined): {
+    providerId: string;
+    modelId: string;
+} | null;
+export declare function shouldFallbackDirectModelForMedia(engine: VirtualRouterEngine, direct: {
+    providerId: string;
+    modelId: string;
+}, features: RoutingFeatures): boolean;