@jsonstudio/rcc 0.90.876 → 0.90.1270

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/bootstrap.js

@@ -1,55 +1,46 @@
 import { VirtualRouterError, VirtualRouterErrorCode } from './types.js';
-import { DEFAULT_CLASSIFIER, DEFAULT_CONTEXT_ROUTING, DEFAULT_HEALTH, DEFAULT_LOAD_BALANCING } from './bootstrap/config-defaults.js';
+import { DEFAULT_LOAD_BALANCING } from './bootstrap/config-defaults.js';
 import { asRecord } from './bootstrap/utils.js';
-import { normalizeClock, normalizeContextRouting, normalizeExecCommandGuard } from './bootstrap/config-normalizers.js';
-import { normalizeHealth, buildProviderProfiles } from './bootstrap/profile-builder.js';
-import { normalizeRouting, expandRoutingTable, buildRuntimeKey } from './bootstrap/routing-config.js';
-import { normalizeProvider } from './bootstrap/provider-normalization.js';
-import { extractProviderAuthEntries } from './bootstrap/auth-utils.js';
-import { normalizeWebSearch, validateWebSearchRouting } from './bootstrap/web-search-config.js';
+import { bootstrapRoutingWithNative } from './engine-selection/native-virtual-router-bootstrap-routing.js';
+import { bootstrapProviderProfilesWithNative, bootstrapProvidersWithNative } from './engine-selection/native-virtual-router-bootstrap-providers.js';
+import { isNativeDisabledByEnv, makeNativeRequiredError } from './engine-selection/native-router-hotpath-policy.js';
+import { loadNativeRouterHotpathBinding } from './engine-selection/native-router-hotpath-loader.js';
+import { parseVirtualRouterNativeError } from './native-error.js';
 export function bootstrapVirtualRouterConfig(input) {
     const section = extractVirtualRouterSection(input);
     const providersSource = asRecord(section.providers);
     if (!Object.keys(providersSource).length) {
         throw new VirtualRouterError('Virtual Router requires at least one provider in configuration', VirtualRouterErrorCode.CONFIG_ERROR);
     }
-    const routingSource = normalizeRouting(section.routing);
-    const webSearch = normalizeWebSearch(section.webSearch, routingSource);
-    validateWebSearchRouting(webSearch, routingSource);
-    const execCommandGuard = normalizeExecCommandGuard(section.execCommandGuard);
-    const clock = normalizeClock(section.clock);
-    const { runtimeEntries, aliasIndex, modelIndex } = buildProviderRuntimeEntries(providersSource);
-    const { routing, targetKeys } = expandRoutingTable(routingSource, aliasIndex, modelIndex);
-    const expandedTargetKeys = new Set(targetKeys);
-    for (const [providerId, aliases] of aliasIndex.entries()) {
-        const models = modelIndex.get(providerId)?.models ?? [];
-        if (!models.length || !aliases.length) {
-            continue;
-        }
-        for (const alias of aliases) {
-            const runtimeKey = buildRuntimeKey(providerId, alias);
-            for (const modelId of models) {
-                if (modelId && typeof modelId === 'string') {
-                    expandedTargetKeys.add(`${runtimeKey}.${modelId}`);
-                }
-            }
-        }
-    }
-    const { profiles: providerProfiles, targetRuntime } = buildProviderProfiles(expandedTargetKeys, runtimeEntries);
-    const classifier = normalizeClassifier(section.classifier);
-    const loadBalancing = section.loadBalancing ?? DEFAULT_LOAD_BALANCING;
-    const health = section.health ?? DEFAULT_HEALTH;
-    const contextRouting = section.contextRouting ?? DEFAULT_CONTEXT_ROUTING;
+    const providersBootstrap = bootstrapProvidersWithNative({ providersSource });
+    const { runtimeEntries, aliasIndex, modelIndex } = providersBootstrap;
+    const routingBootstrap = bootstrapRoutingWithNative({
+        routingSource: section.routing,
+        aliasIndex,
+        modelIndex
+    });
+    const routingSource = routingBootstrap.routingSource;
+    const routing = routingBootstrap.routing;
+    const providerProfilesBootstrap = bootstrapProviderProfilesWithNative({
+        routedTargetKeys: routingBootstrap.targetKeys,
+        aliasIndex,
+        modelIndex,
+        runtimeEntries
+    });
+    const providerProfiles = providerProfilesBootstrap.profiles;
+    const targetRuntime = providerProfilesBootstrap.targetRuntime;
+    const configMeta = bootstrapConfigMetaWithNative(section, routingSource);
+    const loadBalancing = configMeta.loadBalancing ?? DEFAULT_LOAD_BALANCING;
     const config = {
         routing,
         providers: providerProfiles,
-        classifier,
+        classifier: configMeta.classifier,
         loadBalancing,
-        health,
-        contextRouting,
-        ...(webSearch ? { webSearch } : {}),
-        ...(execCommandGuard ? { execCommandGuard } : {}),
-        ...(clock ? { clock } : {})
+        ...(configMeta.health ? { health: configMeta.health } : {}),
+        contextRouting: configMeta.contextRouting,
+        ...(configMeta.webSearch ? { webSearch: configMeta.webSearch } : {}),
+        ...(configMeta.execCommandGuard ? { execCommandGuard: configMeta.execCommandGuard } : {}),
+        ...(configMeta.clock ? { clock: configMeta.clock } : {})
     };
     return {
         config,
@@ -64,271 +55,49 @@ function extractVirtualRouterSection(input) {
     const section = root.virtualrouter && typeof root.virtualrouter === 'object' ? asRecord(root.virtualrouter) : root;
     const providers = asRecord(section.providers ?? root.providers);
     const routing = asRecord(section.routing ?? root.routing);
-    const classifier = (section.classifier ?? root.classifier);
-    const loadBalancing = normalizeLoadBalancing(section.loadBalancing ?? root.loadBalancing);
-    const health = normalizeHealth(section.health ?? root.health);
-    const contextRouting = normalizeContextRouting(section.contextRouting ?? root.contextRouting);
+    const classifier = section.classifier ?? root.classifier;
+    const loadBalancing = section.loadBalancing ?? root.loadBalancing;
+    const health = section.health ?? root.health;
+    const contextRouting = section.contextRouting ?? root.contextRouting;
     const webSearch = section.webSearch ?? root.webSearch;
     const execCommandGuard = section.execCommandGuard ?? root.execCommandGuard;
     const clock = section.clock ?? root.clock;
     return { providers, routing, classifier, loadBalancing, health, contextRouting, webSearch, execCommandGuard, clock };
 }
-function buildProviderRuntimeEntries(providers) {
-    const runtimeEntries = {};
-    const aliasIndex = new Map();
-    const modelIndex = new Map();
-    for (const [providerId, providerRaw] of Object.entries(providers)) {
-        const normalizedProvider = normalizeProvider(providerId, providerRaw);
-        modelIndex.set(providerId, collectProviderModels(providerRaw, normalizedProvider));
-        const authEntries = extractProviderAuthEntries(providerId, providerRaw);
-        if (!authEntries.length) {
-            throw new VirtualRouterError(`Provider ${providerId} requires at least one auth entry`, VirtualRouterErrorCode.CONFIG_ERROR);
-        }
-        aliasIndex.set(providerId, authEntries.map((entry) => entry.keyAlias));
-        for (const entry of authEntries) {
-            const runtimeKey = buildRuntimeKey(providerId, entry.keyAlias);
-            const runtimeAuth = {
-                type: entry.auth.type,
-                rawType: entry.auth.rawType,
-                oauthProviderId: entry.auth.oauthProviderId,
-                secretRef: entry.auth.secretRef,
-                value: entry.auth.value,
-                tokenFile: entry.auth.tokenFile,
-                tokenUrl: entry.auth.tokenUrl,
-                deviceCodeUrl: entry.auth.deviceCodeUrl,
-                clientId: entry.auth.clientId,
-                clientSecret: entry.auth.clientSecret,
-                scopes: entry.auth.scopes && entry.auth.scopes.length ? [...entry.auth.scopes] : undefined,
-                authorizationUrl: entry.auth.authorizationUrl,
-                userInfoUrl: entry.auth.userInfoUrl,
-                refreshUrl: entry.auth.refreshUrl
-            };
-            if (!runtimeAuth.tokenFile && (runtimeAuth.rawType?.includes('oauth') || runtimeAuth.type === 'oauth')) {
-                runtimeAuth.tokenFile = entry.keyAlias;
-            }
-            if (runtimeAuth.type === 'apiKey' && !runtimeAuth.secretRef) {
-                runtimeAuth.secretRef = `${providerId}.${entry.keyAlias}`;
-            }
-            runtimeEntries[runtimeKey] = {
-                runtimeKey,
-                providerId,
-                keyAlias: entry.keyAlias,
-                providerType: normalizedProvider.providerType,
-                endpoint: normalizedProvider.endpoint,
-                headers: normalizedProvider.headers,
-                auth: runtimeAuth,
-                ...(normalizedProvider.enabled !== undefined ? { enabled: normalizedProvider.enabled } : {}),
-                outboundProfile: normalizedProvider.outboundProfile,
-                compatibilityProfile: normalizedProvider.compatibilityProfile,
-                processMode: normalizedProvider.processMode,
-                responsesConfig: normalizedProvider.responsesConfig,
-                streaming: normalizedProvider.streaming,
-                modelStreaming: normalizedProvider.modelStreaming,
-                modelOutputTokens: normalizedProvider.modelOutputTokens,
-                defaultOutputTokens: normalizedProvider.defaultOutputTokens,
-                modelContextTokens: normalizedProvider.modelContextTokens,
-                defaultContextTokens: normalizedProvider.defaultContextTokens,
-                modelAnthropicThinkingConfig: normalizedProvider.modelAnthropicThinkingConfig,
-                defaultAnthropicThinkingConfig: normalizedProvider.defaultAnthropicThinkingConfig,
-                modelAnthropicThinking: normalizedProvider.modelAnthropicThinking,
-                defaultAnthropicThinking: normalizedProvider.defaultAnthropicThinking,
-                modelAnthropicThinkingBudgets: normalizedProvider.modelAnthropicThinkingBudgets,
-                defaultAnthropicThinkingBudgets: normalizedProvider.defaultAnthropicThinkingBudgets,
-                ...(normalizedProvider.deepseek ? { deepseek: normalizedProvider.deepseek } : {}),
-                ...(normalizedProvider.serverToolsDisabled ? { serverToolsDisabled: true } : {}),
-                ...(normalizedProvider.modelCapabilities ? { modelCapabilities: normalizedProvider.modelCapabilities } : {})
-            };
-        }
-    }
-    return { runtimeEntries, aliasIndex, modelIndex };
-}
-function collectProviderModels(providerRaw, _normalizedProvider) {
-    const rawModelsNode = providerRaw.models;
-    const modelsDeclared = rawModelsNode !== undefined;
-    const collected = new Set();
-    if (Array.isArray(rawModelsNode)) {
-        for (const model of rawModelsNode) {
-            if (!model || typeof model !== 'object') {
-                continue;
-            }
-            const modelObj = model;
-            const modelId = typeof modelObj.id === 'string' ? modelObj.id.trim() : '';
-            if (modelId) {
-                collected.add(modelId);
-            }
-            const aliasesNode = Array.isArray(modelObj.aliases)
-                ? modelObj.aliases
-                : [];
-            for (const alias of aliasesNode) {
-                if (typeof alias !== 'string') {
-                    continue;
-                }
-                const normalizedAlias = alias.trim();
-                if (normalizedAlias) {
-                    collected.add(normalizedAlias);
-                }
-            }
-        }
-    }
-    else {
-        const modelsNode = asRecord(rawModelsNode);
-        for (const [modelName, modelConfigRaw] of Object.entries(modelsNode)) {
-            const normalizedModelName = typeof modelName === 'string' ? modelName.trim() : '';
-            if (normalizedModelName) {
-                collected.add(normalizedModelName);
-            }
-            const modelConfig = asRecord(modelConfigRaw);
-            const aliasesNode = Array.isArray(modelConfig.aliases)
-                ? modelConfig.aliases
-                : [];
-            for (const alias of aliasesNode) {
-                if (typeof alias !== 'string') {
-                    continue;
-                }
-                const normalizedAlias = alias.trim();
-                if (normalizedAlias) {
-                    collected.add(normalizedAlias);
-                }
-            }
-        }
+function requireNativeBootstrapConfigFunction(exportName) {
+    if (isNativeDisabledByEnv()) {
+        throw makeNativeRequiredError(exportName, 'native disabled');
     }
-    return { declared: modelsDeclared, models: Array.from(collected) };
-}
-function normalizeClassifier(input) {
-    const normalized = asRecord(input);
-    return {
-        longContextThresholdTokens: typeof normalized.longContextThresholdTokens === 'number'
-            ? normalized.longContextThresholdTokens
-            : DEFAULT_CLASSIFIER.longContextThresholdTokens,
-        thinkingKeywords: normalizeStringArray(normalized.thinkingKeywords, DEFAULT_CLASSIFIER.thinkingKeywords),
-        codingKeywords: normalizeStringArray(normalized.codingKeywords, DEFAULT_CLASSIFIER.codingKeywords),
-        backgroundKeywords: normalizeStringArray(normalized.backgroundKeywords, DEFAULT_CLASSIFIER.backgroundKeywords)
-    };
-}
-function normalizeStringArray(value, fallback) {
-    if (!Array.isArray(value)) {
-        return [...fallback];
+    const binding = loadNativeRouterHotpathBinding();
+    const fn = binding?.[exportName];
+    if (typeof fn !== 'function') {
+        throw makeNativeRequiredError(exportName);
     }
-    const normalized = value.map((item) => (typeof item === 'string' ? item.trim() : '')).filter(Boolean);
-    return normalized.length ? normalized : [...fallback];
+    return fn;
 }
-function normalizeLoadBalancing(input) {
-    if (!input || typeof input !== 'object')
-        return undefined;
-    const record = input;
-    const strategyRaw = typeof record.strategy === 'string' ? record.strategy.trim().toLowerCase() : '';
-    const weightsRaw = asRecord(record.weights);
-    const weightsEntries = {};
-    for (const [key, value] of Object.entries(weightsRaw)) {
-        if (typeof value === 'number' && Number.isFinite(value)) {
-            weightsEntries[key] = value;
-        }
+function bootstrapConfigMetaWithNative(section, routingSource) {
+    const fn = requireNativeBootstrapConfigFunction('bootstrapVirtualRouterConfigMetaJson');
+    let raw;
+    try {
+        raw = fn(JSON.stringify(section), JSON.stringify(routingSource));
     }
-    const healthWeightedRaw = asRecord(record.healthWeighted);
-    const healthWeighted = Object.keys(healthWeightedRaw).length > 0
-        ? {
-            ...(typeof healthWeightedRaw.enabled === 'boolean' ? { enabled: healthWeightedRaw.enabled } : {}),
-            ...(typeof healthWeightedRaw.recoverToBestOnRetry === 'boolean'
-                ? { recoverToBestOnRetry: healthWeightedRaw.recoverToBestOnRetry }
-                : {}),
-            ...(typeof healthWeightedRaw.baseWeight === 'number' && Number.isFinite(healthWeightedRaw.baseWeight)
-                ? { baseWeight: healthWeightedRaw.baseWeight }
-                : {}),
-            ...(typeof healthWeightedRaw.minMultiplier === 'number' && Number.isFinite(healthWeightedRaw.minMultiplier)
-                ? { minMultiplier: healthWeightedRaw.minMultiplier }
-                : {}),
-            ...(typeof healthWeightedRaw.beta === 'number' && Number.isFinite(healthWeightedRaw.beta)
-                ? { beta: healthWeightedRaw.beta }
-                : {}),
-            ...(typeof healthWeightedRaw.halfLifeMs === 'number' && Number.isFinite(healthWeightedRaw.halfLifeMs)
-                ? { halfLifeMs: healthWeightedRaw.halfLifeMs }
-                : {})
-        }
-        : undefined;
-    const contextWeightedRaw = asRecord(record.contextWeighted);
-    const contextWeighted = Object.keys(contextWeightedRaw).length > 0
-        ? {
-            ...(typeof contextWeightedRaw.enabled === 'boolean' ? { enabled: contextWeightedRaw.enabled } : {}),
-            ...(typeof contextWeightedRaw.clientCapTokens === 'number' && Number.isFinite(contextWeightedRaw.clientCapTokens)
-                ? { clientCapTokens: contextWeightedRaw.clientCapTokens }
-                : {}),
-            ...(typeof contextWeightedRaw.gamma === 'number' && Number.isFinite(contextWeightedRaw.gamma)
-                ? { gamma: contextWeightedRaw.gamma }
-                : {}),
-            ...(typeof contextWeightedRaw.maxMultiplier === 'number' && Number.isFinite(contextWeightedRaw.maxMultiplier)
-                ? { maxMultiplier: contextWeightedRaw.maxMultiplier }
-                : {})
-        }
-        : undefined;
-    const aliasSelection = normalizeAliasSelection(record.aliasSelection);
-    const hasNonStrategyConfig = Object.keys(weightsEntries).length > 0 ||
-        Boolean(healthWeighted) ||
-        Boolean(contextWeighted) ||
-        Boolean(aliasSelection);
-    if (!strategyRaw && !hasNonStrategyConfig) {
-        return undefined;
+    catch (error) {
+        const virtualRouterError = parseVirtualRouterNativeError(error);
+        if (virtualRouterError)
+            throw virtualRouterError;
+        throw error;
     }
-    const strategy = strategyRaw === 'weighted' || strategyRaw === 'sticky' ? strategyRaw : 'round-robin';
-    return {
-        strategy,
-        ...(Object.keys(weightsEntries).length ? { weights: weightsEntries } : {}),
-        ...(aliasSelection ? { aliasSelection } : {}),
-        ...(healthWeighted ? { healthWeighted } : {}),
-        ...(contextWeighted ? { contextWeighted } : {})
-    };
-}
-function normalizeAliasSelection(raw) {
-    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
-        return undefined;
+    const returnedVirtualRouterError = parseVirtualRouterNativeError(raw);
+    if (returnedVirtualRouterError) {
+        throw returnedVirtualRouterError;
     }
-    const record = raw;
-    const enabled = typeof record.enabled === 'boolean' ? record.enabled : undefined;
-    const defaultStrategy = coerceAliasSelectionStrategy(record.defaultStrategy);
-    const sessionLeaseCooldownMs = typeof record.sessionLeaseCooldownMs === 'number' && Number.isFinite(record.sessionLeaseCooldownMs)
-        ? Math.max(0, Math.floor(record.sessionLeaseCooldownMs))
-        : typeof record.sessionLease_cooldown_ms === 'number' &&
-            Number.isFinite(record.sessionLease_cooldown_ms)
-            ? Math.max(0, Math.floor(record.sessionLease_cooldown_ms))
-            : undefined;
-    const antigravitySessionBindingRaw = typeof record.antigravitySessionBinding === 'string'
-        ? record.antigravitySessionBinding.trim().toLowerCase()
-        : typeof record.antigravity_session_binding === 'string'
-            ? String(record.antigravity_session_binding).trim().toLowerCase()
-            : '';
-    const antigravitySessionBinding = antigravitySessionBindingRaw === 'strict'
-        ? 'strict'
-        : antigravitySessionBindingRaw === 'lease'
-            ? 'lease'
-            : undefined;
-    const providersRaw = asRecord(record.providers);
-    const providers = {};
-    for (const [providerId, value] of Object.entries(providersRaw)) {
-        const strategy = coerceAliasSelectionStrategy(value);
-        if (strategy) {
-            providers[providerId] = strategy;
-        }
-    }
-    const out = {
-        ...(enabled !== undefined ? { enabled } : {}),
-        ...(defaultStrategy ? { defaultStrategy } : {}),
-        ...(sessionLeaseCooldownMs !== undefined ? { sessionLeaseCooldownMs } : {}),
-        ...(antigravitySessionBinding ? { antigravitySessionBinding } : {}),
-        ...(Object.keys(providers).length ? { providers } : {})
-    };
-    return Object.keys(out).length ? out : undefined;
-}
-function coerceAliasSelectionStrategy(value) {
-    if (typeof value !== 'string') {
-        return undefined;
+    if (typeof raw !== 'string' || !raw) {
+        throw new VirtualRouterError('Virtual router native config bootstrap returned empty payload', VirtualRouterErrorCode.CONFIG_ERROR);
     }
-    const normalized = value.trim().toLowerCase();
-    if (!normalized) {
-        return undefined;
+    try {
+        return JSON.parse(raw);
     }
-    if (normalized === 'none')
-        return 'none';
-    if (normalized === 'sticky-queue' || normalized === 'sticky_queue' || normalized === 'stickyqueue') {
-        return 'sticky-queue';
+    catch {
+        throw new VirtualRouterError('Virtual router native config bootstrap returned invalid payload', VirtualRouterErrorCode.CONFIG_ERROR);
     }
-    return undefined;
 }

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/classifier.js

@@ -10,25 +10,24 @@ export class RoutingClassifier {
         };
     }
     classify(features) {
-        const lastToolCategory = features.lastAssistantToolCategory;
-        const webSearchIntent = detectWebSearchIntent(features.userTextSample);
-        const serverToolRequired = features.metadata?.serverToolRequired === true;
+        const latestMessageFromUser = features.latestMessageFromUser === true;
+        const lastToolCategory = latestMessageFromUser ? undefined : features.lastAssistantToolCategory;
         const webSearchContinuation = lastToolCategory === 'websearch';
         const localToolContinuation = lastToolCategory === 'read' ||
             lastToolCategory === 'write' ||
             lastToolCategory === 'search' ||
             lastToolCategory === 'other';
-        const webSearchFromIntent = !localToolContinuation && webSearchIntent;
-        const webSearchDeclaredOrRequired = !localToolContinuation && serverToolRequired;
         const reachedLongContext = features.estimatedTokens >= (this.config.longContextThresholdTokens ?? DEFAULT_LONG_CONTEXT_THRESHOLD);
-        const latestMessageFromUser = features.latestMessageFromUser === true;
+        const hasToolActivity = features.hasTools || (!latestMessageFromUser && features.hasToolCallResponses);
         const thinkingContinuation = lastToolCategory === 'read';
+        // Jason 规则：当前轮是用户输入时始终优先 thinking，
+        // 但不再引用历史 last-tool continuation 影响本轮判断。
+        // （tools 仍可作为并行诊断信号，避免“thinking 与 tools 冲突”）
         const thinkingFromUser = latestMessageFromUser;
         const thinkingFromRead = !thinkingFromUser && thinkingContinuation;
         const codingContinuation = lastToolCategory === 'write';
         const searchContinuation = lastToolCategory === 'search';
         const toolsContinuation = lastToolCategory === 'other';
-        const hasToolActivity = features.hasTools || features.hasToolCallResponses;
         const hasRemoteVideoAttachment = features.hasVideoAttachment === true && features.hasRemoteVideoAttachment === true;
         const evaluationMap = {
             video: {
@@ -52,18 +51,11 @@ export class RoutingClassifier {
                 reason: 'coding:last-tool-write'
             },
             web_search: {
-                // web_search 路由触发条件（按优先级）：
-                // 1) 上一轮 assistant 已触发 websearch 类工具（续写命中）
-                // 2) 本轮已标记 serverToolRequired（例如 stage1 注入 websearch 工具）
-                // 3) 用户输入命中联网搜索意图关键词
-                triggered: webSearchContinuation ||
-                    webSearchDeclaredOrRequired ||
-                    webSearchFromIntent,
-                reason: webSearchContinuation
-                    ? 'web_search:last-tool-websearch'
-                    : webSearchDeclaredOrRequired && serverToolRequired
-                        ? 'web_search:servertool-required'
-                        : 'web_search:intent-keyword'
+                // web_search 路由只允许由显式 web_search 工具链续写命中。
+                // 不再因为用户“想联网搜索”或 serverToolRequired 自动切到 web_search，
+                // 以避免产生隐式联网流量；首次显式工具请求仍走 tools 路由。
+                triggered: !localToolContinuation && webSearchContinuation,
+                reason: 'web_search:last-tool-websearch'
             },
             search: {
                 // search 路由：仅在上一轮 assistant 使用 search 类工具时继续命中，
@@ -121,69 +113,6 @@ export class RoutingClassifier {
         return index >= 0 ? index : ROUTE_PRIORITY.length;
     }
 }
-function detectWebSearchIntent(text) {
-    if (!text || !text.trim()) {
-        return false;
-    }
-    const normalized = text.toLowerCase();
-    if (isNegativeWebSearchContext(normalized, text)) {
-        return false;
-    }
-    const directKeywords = [
-        'web search',
-        'web_search',
-        'websearch',
-        'search the web',
-        'internet search',
-        '搜索网页',
-        '联网搜索',
-        '上网搜索',
-        '上网查',
-        '网上搜',
-        '谷歌搜索',
-        'google search'
-    ];
-    if (directKeywords.some((keyword) => normalized.includes(keyword))) {
-        return true;
-    }
-    const enVerb = ['search', 'find', 'lookup', 'look up', 'google'];
-    const enNoun = ['web', 'internet', 'online', 'google', 'bing'];
-    const hasEnVerb = enVerb.some((keyword) => normalized.includes(keyword));
-    const hasEnNoun = enNoun.some((keyword) => normalized.includes(keyword));
-    if (hasEnVerb && hasEnNoun) {
-        return true;
-    }
-    const zhVerb = ['搜索', '查找', '搜', '上网查', '上网搜', '联网查', '联网搜'];
-    const zhNoun = ['网络', '联网', '网页', '网上', '互联网', '谷歌', '百度'];
-    const hasZhVerb = zhVerb.some((keyword) => text.includes(keyword));
-    const hasZhNoun = zhNoun.some((keyword) => text.includes(keyword));
-    if ((text.includes('上网') || text.includes('联网')) && (text.includes('搜') || text.includes('查'))) {
-        return true;
-    }
-    if (hasZhVerb && hasZhNoun) {
-        return true;
-    }
-    return false;
-}
-function isNegativeWebSearchContext(normalized, originalText) {
-    const englishPatterns = [
-        /prefer\s+resources?\s+over\s+web[\s_-]?search/u,
-        /prefer[\s\S]{0,40}web[\s_-]?search/u,
-        /do\s+not[\s\S]{0,20}web[\s_-]?search/u,
-        /don't[\s\S]{0,20}web[\s_-]?search/u,
-        /without[\s\S]{0,20}web[\s_-]?search/u,
-        /cannot[\s\S]{0,20}web[\s_-]?search/u
-    ];
-    if (englishPatterns.some((pattern) => pattern.test(normalized))) {
-        return true;
-    }
-    const chinesePatterns = [
-        /不能.{0,20}(上网|联网|web[_ -]?search|搜索网页)/u,
-        /不要.{0,20}(上网|联网|web[_ -]?search|搜索网页)/u,
-        /避免.{0,20}(上网|联网|web[_ -]?search|搜索网页)/u
-    ];
-    return chinesePatterns.some((pattern) => pattern.test(originalText));
-}
 function normalizeList(source, fallback) {
     if (!source || source.length === 0) {
         return fallback;

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/engine/antigravity/alias-lease.js

@@ -1,6 +1,26 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { resolveRccPath, resolveRccPathForRead } from '../../../../runtime/user-data-paths.js';
+function formatUnknownError(error) {
+    if (error instanceof Error) {
+        return error.stack || `${error.name}: ${error.message}`;
+    }
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error);
+    }
+}
+function logAliasLeaseNonBlockingError(stage, error, details) {
+    try {
+        const suffix = details && Object.keys(details).length > 0 ? ` details=${JSON.stringify(details)}` : '';
+        console.warn(`[alias-lease] ${stage} failed (non-blocking): ${formatUnknownError(error)}${suffix}`);
+    }
+    catch {
+        void 0;
+    }
+}
 export function resolveAntigravityAliasReuseCooldownMs(config) {
     const cfg = config.loadBalancing?.aliasSelection?.sessionLeaseCooldownMs;
     if (typeof cfg === 'number' && Number.isFinite(cfg)) {
@@ -17,7 +37,8 @@ function resolveAntigravityLeaseScope(providerRegistry, providerKey) {
         }
         return null;
     }
-    catch {
+    catch (resolveScopeError) {
+        logAliasLeaseNonBlockingError('resolveAntigravityLeaseScope', resolveScopeError, { providerKey });
         return null;
     }
 }
@@ -53,7 +74,8 @@ function resolveAntigravityAliasLeasePersistWritePath() {
         }
         return resolveRccPath('state', 'antigravity-alias-leases.json');
     }
-    catch {
+    catch (resolveWritePathError) {
+        logAliasLeaseNonBlockingError('resolveAntigravityAliasLeasePersistWritePath', resolveWritePathError);
         return null;
     }
 }
@@ -66,7 +88,8 @@ function resolveAntigravityAliasLeasePersistReadPath() {
         const resolved = resolveRccPathForRead('state', 'antigravity-alias-leases.json');
         return fs.existsSync(resolved) ? resolved : writePath;
     }
-    catch {
+    catch (resolveReadPathError) {
+        logAliasLeaseNonBlockingError('resolveAntigravityAliasLeasePersistReadPath', resolveReadPathError);
         return null;
     }
 }
@@ -80,7 +103,8 @@ export function hydrateAntigravityAliasLeaseStoreIfNeeded(options) {
     try {
         stat = fs.statSync(filePath);
     }
-    catch {
+    catch (statError) {
+        logAliasLeaseNonBlockingError('hydrateAntigravityAliasLeaseStoreIfNeeded.statSync', statError, { filePath });
         options.persistence.loadedOnce = true;
         options.persistence.loadedMtimeMs = null;
         return;
@@ -93,7 +117,8 @@ export function hydrateAntigravityAliasLeaseStoreIfNeeded(options) {
     try {
         parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
     }
-    catch {
+    catch (readError) {
+        logAliasLeaseNonBlockingError('hydrateAntigravityAliasLeaseStoreIfNeeded.readParse', readError, { filePath });
         options.persistence.loadedOnce = true;
         options.persistence.loadedMtimeMs = mtimeMs;
         return;
@@ -152,8 +177,8 @@ function flushAntigravityAliasLeaseStoreSync(options) {
     try {
         fs.mkdirSync(path.dirname(filePath), { recursive: true });
     }
-    catch {
-        // ignore
+    catch (mkdirError) {
+        logAliasLeaseNonBlockingError('flushAntigravityAliasLeaseStoreSync.mkdirSync', mkdirError, { filePath });
     }
     const now = Date.now();
     const cooldownMs = options.aliasReuseCooldownMs;
@@ -177,12 +202,12 @@ function flushAntigravityAliasLeaseStoreSync(options) {
             options.persistence.loadedOnce = true;
             options.persistence.loadedMtimeMs = mtimeMs;
         }
-        catch {
-            // ignore
+        catch (statError) {
+            logAliasLeaseNonBlockingError('flushAntigravityAliasLeaseStoreSync.statSync', statError, { filePath });
         }
     }
-    catch {
-        // best-effort persistence: must not affect routing
+    catch (flushError) {
+        logAliasLeaseNonBlockingError('flushAntigravityAliasLeaseStoreSync.writeRename', flushError, { filePath });
     }
 }
 function scheduleAntigravityAliasLeaseStoreFlush(options) {
@@ -211,8 +236,8 @@ export function recordAntigravitySessionLease(options) {
             }
         }
     }
-    catch {
-        // ignore metadata parse errors
+    catch (metadataError) {
+        logAliasLeaseNonBlockingError('recordAntigravitySessionLease.metadataOverrideParse', metadataError);
     }
     const sessionKey = options.sessionKey;
     if (!sessionKey) {
@@ -251,7 +276,9 @@ export function recordAntigravitySessionLease(options) {
             prev: existing?.sessionKey ?? null
         });
     }
-    catch {
-        // ignore
+    catch (debugLogError) {
+        logAliasLeaseNonBlockingError('recordAntigravitySessionLease.debugLog', debugLogError, {
+            runtimeKey
+        });
     }
 }