@jsonstudio/llms 0.6.2172 → 0.6.3214

package/dist/router/virtual-router/engine-legacy/direct-model.js

@@ -0,0 +1,38 @@
+import { routeHasTargets } from './route-utils.js';
+export function parseDirectProviderModel(engine, model) {
+    const raw = typeof model === 'string' ? model.trim() : '';
+    if (!raw) {
+        return null;
+    }
+    const firstDot = raw.indexOf('.');
+    if (firstDot <= 0 || firstDot === raw.length - 1) {
+        return null;
+    }
+    const providerId = raw.slice(0, firstDot).trim();
+    const modelId = raw.slice(firstDot + 1).trim();
+    if (!providerId || !modelId) {
+        return null;
+    }
+    if (engine.providerRegistry.listProviderKeys(providerId).length === 0) {
+        return null;
+    }
+    return { providerId, modelId };
+}
+export function shouldFallbackDirectModelForMedia(engine, direct, features) {
+    if (!features.hasImageAttachment) {
+        return false;
+    }
+    const providerId = direct.providerId.trim().toLowerCase();
+    const modelId = direct.modelId.trim().toLowerCase();
+    if (providerId !== 'qwen') {
+        return false;
+    }
+    const isQwen35Plus = modelId === 'qwen3.5-plus' || modelId === 'qwen3-5-plus' || modelId === 'qwen3_5-plus';
+    if (!isQwen35Plus) {
+        return false;
+    }
+    if (!(features.hasVideoAttachment === true && features.hasLocalVideoAttachment === true)) {
+        return false;
+    }
+    return routeHasTargets(engine, engine.routing.vision);
+}

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

@@ -0,0 +1,13 @@
+import type { ProviderErrorEvent, ProviderFailureEvent, ProviderHealthConfig, ProviderSuccessEvent, VirtualRouterHealthSnapshot } from '../types.js';
+import type { VirtualRouterEngine } from '../engine-legacy.js';
+export declare function providerHealthConfig(engine: VirtualRouterEngine): Required<ProviderHealthConfig>;
+export declare function markProviderCooldown(engine: VirtualRouterEngine, providerKey: string, cooldownMs: number | undefined): void;
+export declare function clearProviderCooldown(engine: VirtualRouterEngine, providerKey: string): void;
+export declare function isProviderCoolingDown(engine: VirtualRouterEngine, providerKey: string): boolean;
+export declare function getProviderCooldownRemainingMs(engine: VirtualRouterEngine, providerKey: string): number;
+export declare function restoreHealthFromStore(engine: VirtualRouterEngine): void;
+export declare function buildHealthSnapshot(engine: VirtualRouterEngine): VirtualRouterHealthSnapshot;
+export declare function persistHealthSnapshot(engine: VirtualRouterEngine): void;
+export declare function handleProviderFailure(engine: VirtualRouterEngine, event: ProviderFailureEvent): void;
+export declare function handleProviderError(engine: VirtualRouterEngine, event: ProviderErrorEvent): void;
+export declare function handleProviderSuccess(engine: VirtualRouterEngine, event: ProviderSuccessEvent): void;

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

@@ -0,0 +1,104 @@
+import { applyAntigravityRiskPolicyImpl, applyQuotaDepletedImpl, applyQuotaRecoveryImpl, applySeriesCooldownImpl, handleProviderFailureImpl, mapProviderErrorImpl } from '../engine/health/index.js';
+import { recordAntigravitySessionLease } from '../engine/antigravity/alias-lease.js';
+export function providerHealthConfig(engine) {
+    return engine.healthManager.getConfig();
+}
+export function markProviderCooldown(engine, providerKey, cooldownMs) {
+    engine.cooldownManager.markProviderCooldown(providerKey, cooldownMs);
+}
+export function clearProviderCooldown(engine, providerKey) {
+    engine.cooldownManager.clearProviderCooldown(providerKey);
+}
+export function isProviderCoolingDown(engine, providerKey) {
+    return engine.cooldownManager.isProviderCoolingDown(providerKey);
+}
+export function getProviderCooldownRemainingMs(engine, providerKey) {
+    if (!providerKey) {
+        return 0;
+    }
+    const expiry = engine.cooldownManager.getCooldownMap().get(providerKey);
+    if (!expiry || !Number.isFinite(expiry)) {
+        return 0;
+    }
+    const remaining = Math.floor(expiry - Date.now());
+    return remaining > 0 ? remaining : 0;
+}
+export function restoreHealthFromStore(engine) {
+    engine.cooldownManager.restoreHealthFromStore();
+}
+export function buildHealthSnapshot(engine) {
+    const providers = engine.healthManager.getSnapshot();
+    const cooldownSnapshot = engine.cooldownManager.buildHealthSnapshot();
+    return { providers, cooldowns: cooldownSnapshot.cooldowns };
+}
+export function persistHealthSnapshot(engine) {
+    engine.cooldownManager.persistHealthSnapshot();
+}
+export function handleProviderFailure(engine, event) {
+    handleProviderFailureImpl(event, engine.healthManager, providerHealthConfig(engine), (key, ttl) => markProviderCooldown(engine, key, ttl));
+}
+export function handleProviderError(engine, event) {
+    if (engine.healthStore && typeof engine.healthStore.recordProviderError === 'function') {
+        try {
+            engine.healthStore.recordProviderError(event);
+        }
+        catch {
+            // ignore persistence errors
+        }
+    }
+    // Quota routing mode: health/cooldown must be driven by quotaView only (host/core quota center).
+    // VirtualRouter must not produce or persist its own cooldown state in this mode.
+    // 当 Host 注入 quotaView 时，VirtualRouter 的入池/优先级决策应以 quota 为准；
+    // 此时不再在 engine-health 内部进行 429/backoff/series cooldown 等健康决策，
+    // 以避免与 daemon/quota-center 的长期熔断策略重复维护并导致日志噪声。
+    if (engine.quotaView) {
+        return;
+    }
+    // Antigravity account safety policy uses router-local cooldown TTLs; only applies when quota routing is disabled.
+    applyAntigravityRiskPolicyImpl(event, engine.providerRegistry, engine.healthManager, (key, ttl) => markProviderCooldown(engine, key, ttl), engine.debug);
+    // 配额恢复事件优先处理：一旦识别到 virtualRouterQuotaRecovery，
+    // 直接清理健康状态/冷却 TTL，避免继续走常规错误映射逻辑。
+    const handledByQuota = applyQuotaRecoveryImpl(event, engine.healthManager, (key) => clearProviderCooldown(engine, key), engine.debug);
+    if (handledByQuota) {
+        return;
+    }
+    const handledByQuotaDepleted = applyQuotaDepletedImpl(event, engine.healthManager, (key, ttl) => markProviderCooldown(engine, key, ttl), engine.debug);
+    if (handledByQuotaDepleted) {
+        return;
+    }
+    applySeriesCooldownImpl(event, engine.providerRegistry, engine.healthManager, (key, ttl) => markProviderCooldown(engine, key, ttl), engine.debug);
+    const derived = mapProviderErrorImpl(event, providerHealthConfig(engine));
+    if (!derived) {
+        return;
+    }
+    handleProviderFailure(engine, derived);
+}
+export function handleProviderSuccess(engine, event) {
+    if (!event || typeof event !== 'object') {
+        return;
+    }
+    const providerKey = event.runtime && typeof event.runtime.providerKey === 'string' ? event.runtime.providerKey.trim() : '';
+    if (!providerKey) {
+        return;
+    }
+    const metadata = event.metadata && typeof event.metadata === 'object' && !Array.isArray(event.metadata)
+        ? event.metadata
+        : null;
+    if (!metadata) {
+        return;
+    }
+    if (providerKey.toLowerCase().startsWith('antigravity.')) {
+        recordAntigravitySessionLease({
+            metadata: metadata,
+            providerKey,
+            sessionKey: engine.resolveSessionScope(metadata),
+            providerRegistry: engine.providerRegistry,
+            leaseStore: engine.stickySessionManager.getAllStores().aliasLeaseStore,
+            sessionAliasStore: engine.stickySessionManager.getAllStores().sessionAliasStore,
+            persistence: engine.antigravityLeasePersistence,
+            aliasReuseCooldownMs: engine.stickySessionManager.getAliasReuseCooldownMs(),
+            commitSessionBinding: true,
+            debug: engine.debug
+        });
+    }
+}

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

@@ -0,0 +1,16 @@
+import type { StandardizedMessage } from '../../../conversion/hub/types/standardized.js';
+import type { RouterMetadataInput } from '../types.js';
+import type { RoutingInstructionState } from '../routing-instructions.js';
+export declare const DEFAULT_STOP_MESSAGE_MAX_REPEATS = 10;
+export declare function isStopScopeTraceEnabled(): boolean;
+export declare function normalizeStopMessageStageMode(value: unknown): 'on' | 'off' | 'auto' | undefined;
+export declare function normalizeStopMessageAiMode(value: unknown): 'on' | 'off' | undefined;
+export declare function stripStopMessageFields(state: RoutingInstructionState): RoutingInstructionState;
+export declare function stripClientInjectScopedFields(state: RoutingInstructionState): RoutingInstructionState;
+export declare function hasClientInjectScopedFields(state: RoutingInstructionState | null | undefined): boolean;
+export declare function hasRoutingInstructionMarker(messages: StandardizedMessage[]): boolean;
+export declare function hasLatestUserRoutingInstructionMarker(messages: StandardizedMessage[]): boolean;
+export declare function getLatestUserTextFromResponsesContext(context: unknown): string;
+export declare function hasRoutingInstructionMarkerInResponsesContext(context: unknown): boolean;
+export declare function cleanResponsesContextFromRoutingInstructions(context: unknown): void;
+export declare function isServerToolFollowupRequest(metadata: RouterMetadataInput): boolean;

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

@@ -0,0 +1,226 @@
+import { extractMessageText } from '../message-utils.js';
+export const DEFAULT_STOP_MESSAGE_MAX_REPEATS = 10;
+export function isStopScopeTraceEnabled() {
+    const raw = String(process.env.ROUTECODEX_STOP_SCOPE_TRACE ?? process.env.RCC_STOP_SCOPE_TRACE ?? '')
+        .trim()
+        .toLowerCase();
+    return (raw === '1' ||
+        raw === 'true' ||
+        raw === 'on' ||
+        raw === 'yes' ||
+        raw === 'debug' ||
+        raw === 'trace' ||
+        raw === 'verbose');
+}
+export 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;
+}
+export function normalizeStopMessageAiMode(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'on' || normalized === 'off') {
+        return normalized;
+    }
+    return undefined;
+}
+export function stripStopMessageFields(state) {
+    return {
+        ...state,
+        stopMessageSource: undefined,
+        stopMessageText: undefined,
+        stopMessageMaxRepeats: undefined,
+        stopMessageUsed: undefined,
+        stopMessageUpdatedAt: undefined,
+        stopMessageLastUsedAt: undefined,
+        stopMessageStageMode: undefined,
+        stopMessageAiMode: undefined,
+        stopMessageAiSeedPrompt: undefined,
+        stopMessageAiHistory: undefined
+    };
+}
+export function stripClientInjectScopedFields(state) {
+    return {
+        ...stripStopMessageFields(state),
+        preCommandSource: undefined,
+        preCommandScriptPath: undefined,
+        preCommandUpdatedAt: undefined
+    };
+}
+export function hasClientInjectScopedFields(state) {
+    if (!state) {
+        return false;
+    }
+    return (typeof state.stopMessageText === 'string' ||
+        typeof state.stopMessageMaxRepeats === 'number' ||
+        typeof state.stopMessageUsed === 'number' ||
+        typeof state.stopMessageStageMode === 'string' ||
+        typeof state.stopMessageAiMode === 'string' ||
+        typeof state.stopMessageAiSeedPrompt === 'string' ||
+        Array.isArray(state.stopMessageAiHistory) ||
+        typeof state.preCommandScriptPath === 'string' ||
+        typeof state.preCommandUpdatedAt === 'number');
+}
+export function hasRoutingInstructionMarker(messages) {
+    for (const message of messages) {
+        if (!message || message.role !== 'user') {
+            continue;
+        }
+        const content = extractMessageText(message);
+        if (!content) {
+            continue;
+        }
+        if (/<\*\*[\s\S]*?\*\*>/.test(content)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function hasLatestUserRoutingInstructionMarker(messages) {
+    for (let idx = messages.length - 1; idx >= 0; idx -= 1) {
+        const message = messages[idx];
+        if (!message) {
+            continue;
+        }
+        if (message.role !== 'user') {
+            return false;
+        }
+        const content = extractMessageText(message);
+        if (!content) {
+            return false;
+        }
+        return /<\*\*[\s\S]*?\*\*>/.test(content);
+    }
+    return false;
+}
+function extractResponsesInputText(entry) {
+    if (typeof entry.content === 'string' && entry.content.trim()) {
+        return entry.content;
+    }
+    if (Array.isArray(entry.content)) {
+        return extractMessageText({ role: 'user', content: entry.content });
+    }
+    return '';
+}
+export function getLatestUserTextFromResponsesContext(context) {
+    if (!context || typeof context !== 'object') {
+        return '';
+    }
+    const input = context.input;
+    if (!Array.isArray(input) || input.length === 0) {
+        return '';
+    }
+    for (let idx = input.length - 1; idx >= 0; idx -= 1) {
+        const entry = input[idx];
+        if (!entry || typeof entry !== 'object') {
+            continue;
+        }
+        const record = entry;
+        const entryType = typeof record.type === 'string' ? record.type.trim().toLowerCase() : 'message';
+        if (entryType !== 'message') {
+            continue;
+        }
+        const role = typeof record.role === 'string' ? record.role.trim().toLowerCase() : 'user';
+        if (role !== 'user') {
+            continue;
+        }
+        const text = extractResponsesInputText(record).trim();
+        if (text) {
+            return text;
+        }
+    }
+    return '';
+}
+export function hasRoutingInstructionMarkerInResponsesContext(context) {
+    const latestUserText = getLatestUserTextFromResponsesContext(context);
+    if (!latestUserText) {
+        return false;
+    }
+    return /<\*\*[\s\S]*?\*\*>/.test(latestUserText);
+}
+export function cleanResponsesContextFromRoutingInstructions(context) {
+    if (!context || typeof context !== 'object') {
+        return;
+    }
+    const record = context;
+    if (!Array.isArray(record.input)) {
+        return;
+    }
+    const cleaned = record.input
+        .map((entry) => {
+        if (!entry || typeof entry !== 'object') {
+            return entry;
+        }
+        const row = entry;
+        const entryType = typeof row.type === 'string' ? row.type.trim().toLowerCase() : 'message';
+        if (entryType !== 'message') {
+            return entry;
+        }
+        const role = typeof row.role === 'string' ? row.role.trim().toLowerCase() : 'user';
+        if (role !== 'user') {
+            return entry;
+        }
+        if (typeof row.content === 'string') {
+            const cleanedText = row.content.replace(/<\*\*[\s\S]*?\*\*>/g, '').trim();
+            if (!cleanedText) {
+                return null;
+            }
+            return { ...row, content: cleanedText };
+        }
+        if (Array.isArray(row.content)) {
+            const nextContent = row.content
+                .map((part) => {
+                if (typeof part === 'string') {
+                    const cleanedText = part.replace(/<\*\*[\s\S]*?\*\*>/g, '').trim();
+                    return cleanedText ? cleanedText : null;
+                }
+                if (!part || typeof part !== 'object' || Array.isArray(part)) {
+                    return part;
+                }
+                const partRecord = part;
+                if (typeof partRecord.text === 'string') {
+                    const cleanedText = partRecord.text.replace(/<\*\*[\s\S]*?\*\*>/g, '').trim();
+                    if (!cleanedText) {
+                        return null;
+                    }
+                    return { ...partRecord, text: cleanedText };
+                }
+                if (typeof partRecord.content === 'string') {
+                    const cleanedText = partRecord.content.replace(/<\*\*[\s\S]*?\*\*>/g, '').trim();
+                    if (!cleanedText) {
+                        return null;
+                    }
+                    return { ...partRecord, content: cleanedText };
+                }
+                return part;
+            })
+                .filter((part) => part !== null);
+            if (!nextContent.length) {
+                return null;
+            }
+            return { ...row, content: nextContent };
+        }
+        return entry;
+    })
+        .filter((entry) => entry !== null);
+    record.input = cleaned;
+}
+export function isServerToolFollowupRequest(metadata) {
+    if (!metadata || typeof metadata !== 'object') {
+        return false;
+    }
+    const rt = metadata.__rt;
+    if (!rt || typeof rt !== 'object' || Array.isArray(rt)) {
+        return false;
+    }
+    const flag = rt.serverToolFollowup;
+    return flag === true || (typeof flag === 'string' && flag.trim().toLowerCase() === 'true');
+}

package/dist/router/virtual-router/engine-legacy/route-finalize.d.ts

@@ -0,0 +1,9 @@
+import type { RoutingInstruction, RoutingInstructionState } from '../routing-instructions.js';
+import type { RouterMetadataInput, TargetMetadata, RoutingDecision, RoutingDiagnostics } from '../types.js';
+import type { VirtualRouterEngine } from '../engine-legacy.js';
+import type { RoutingSelectionResult } from './route-selection.js';
+export declare function finalizeRoutingDecision(engine: VirtualRouterEngine, metadata: RouterMetadataInput, routingState: RoutingInstructionState, metadataInstructions: RoutingInstruction[], instructions: RoutingInstruction[], selectionResult: RoutingSelectionResult): {
+    target: TargetMetadata;
+    decision: RoutingDecision;
+    diagnostics: RoutingDiagnostics;
+};

package/dist/router/virtual-router/engine-legacy/route-finalize.js

@@ -0,0 +1,84 @@
+import { resolveRoutingMode } from '../engine/routing-state/metadata.js';
+import { buildHitReason, createVirtualRouterHitRecord, formatVirtualRouterHit, toVirtualRouterHitEvent } from '../engine-logging.js';
+import { recordAntigravitySessionLease } from '../engine/antigravity/alias-lease.js';
+export function finalizeRoutingDecision(engine, metadata, routingState, metadataInstructions, instructions, selectionResult) {
+    const { selection, classification, requestedRoute, features } = selectionResult;
+    const baseTarget = engine.providerRegistry.buildTarget(selection.providerKey);
+    const forceVision = selection.routeUsed === 'vision' && engine.routeHasForceFlag('vision');
+    const target = {
+        ...baseTarget,
+        ...(engine.webSearchForce ? { forceWebSearch: true } : {}),
+        ...(forceVision ? { forceVision: true } : {})
+    };
+    const instructionProcessMode = engine.resolveInstructionProcessModeForSelection(selection.providerKey, routingState);
+    if (instructionProcessMode) {
+        target.processMode = instructionProcessMode;
+    }
+    recordAntigravitySessionLease({
+        metadata: features.metadata,
+        providerKey: selection.providerKey,
+        sessionKey: engine.resolveSessionScope(features.metadata),
+        providerRegistry: engine.providerRegistry,
+        leaseStore: engine.stickySessionManager.getAllStores().aliasLeaseStore,
+        sessionAliasStore: engine.stickySessionManager.getAllStores().sessionAliasStore,
+        persistence: engine.antigravityLeasePersistence,
+        aliasReuseCooldownMs: engine.stickySessionManager.getAliasReuseCooldownMs(),
+        commitSessionBinding: false,
+        debug: engine.debug
+    });
+    const routingMode = resolveRoutingMode([...metadataInstructions, ...instructions], routingState);
+    const hitReason = buildHitReason(selection.routeUsed, selection.providerKey, classification, features, routingMode, { providerRegistry: engine.providerRegistry, contextRouting: engine.contextRouting });
+    const stickyScope = routingMode !== 'none' ? engine.resolveSessionScope(metadata) : undefined;
+    const routeForLog = routingMode === 'sticky' ? 'sticky' : selection.routeUsed;
+    const hitRecord = createVirtualRouterHitRecord({
+        requestId: metadata.requestId,
+        routeName: routeForLog,
+        poolId: selection.poolId,
+        providerKey: selection.providerKey,
+        modelId: target.modelId || undefined,
+        hitReason,
+        stickyScope,
+        routingState,
+        requestTokens: features.estimatedTokens,
+        selectionPenalty: engine.resolveSelectionPenalty(selection.providerKey)
+    });
+    engine.routeAnalytics.incrementRouteStat(selection.routeUsed, selection.providerKey, hitRecord);
+    try {
+        engine.statsCenter.recordVirtualRouterHit(toVirtualRouterHitEvent(hitRecord, {
+            requestId: metadata.requestId,
+            entryEndpoint: metadata.entryEndpoint || '/v1/chat/completions'
+        }));
+    }
+    catch {
+        // stats must never break routing
+    }
+    const formatted = formatVirtualRouterHit(hitRecord);
+    if (formatted) {
+        engine.debug?.log?.(formatted);
+    }
+    else {
+        engine.debug?.log?.(formatVirtualRouterHit(hitRecord));
+    }
+    const didFallback = selection.routeUsed !== requestedRoute;
+    return {
+        target,
+        decision: {
+            routeName: selection.routeUsed,
+            providerKey: selection.providerKey,
+            pool: selection.pool,
+            poolId: selection.poolId,
+            confidence: classification.confidence,
+            reasoning: classification.reasoning,
+            fallback: didFallback
+        },
+        diagnostics: {
+            routeName: selection.routeUsed,
+            providerKey: selection.providerKey,
+            pool: selection.pool,
+            poolId: selection.poolId,
+            reasoning: classification.reasoning,
+            fallback: didFallback,
+            confidence: classification.confidence
+        }
+    };
+}

package/dist/router/virtual-router/engine-legacy/route-selection.d.ts

@@ -0,0 +1,17 @@
+import type { ProcessedRequest, StandardizedRequest } from '../../../conversion/hub/types/standardized.js';
+import type { ClassificationResult, RoutingFeatures, RouterMetadataInput } from '../types.js';
+import type { RoutingInstructionState } from '../routing-instructions.js';
+import type { VirtualRouterEngine } from '../engine-legacy.js';
+export type RoutingSelectionResult = {
+    routingState: RoutingInstructionState;
+    requestedRoute: string;
+    classification: ClassificationResult;
+    selection: {
+        providerKey: string;
+        routeUsed: string;
+        pool: string[];
+        poolId?: string;
+    };
+    features: RoutingFeatures;
+};
+export declare function selectRoutingTarget(engine: VirtualRouterEngine, request: StandardizedRequest | ProcessedRequest, metadata: RouterMetadataInput, routingState: RoutingInstructionState, stateKey: string): RoutingSelectionResult;