@jsonstudio/rcc 0.89.168 → 0.89.524

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

@@ -12,32 +12,33 @@ export class RoutingClassifier {
     classify(features) {
         const lastToolCategory = features.lastAssistantToolCategory;
         const reachedLongContext = features.estimatedTokens >= (this.config.longContextThresholdTokens ?? DEFAULT_LONG_CONTEXT_THRESHOLD);
-        const thinkingKeywordHit = features.hasThinkingKeyword ||
-            containsKeywords(features.userTextSample, this.config.thinkingKeywords ?? []);
+        const latestMessageFromUser = features.latestMessageFromUser === true;
         const codingContinuation = lastToolCategory === 'write';
         const thinkingContinuation = lastToolCategory === 'read';
         const searchContinuation = lastToolCategory === 'search';
         const toolsContinuation = lastToolCategory === 'other';
+        // 用户输入优先级最高(仅次于 vision),确保每次新的用户输入都走 thinking 路由进行工具检查
+        // thinking_continuation 用于区分"工具轮次中的 read 类调用"与"用户新输入"
         const evaluationMap = {
             vision: {
-                triggered: features.hasVisionTool && features.hasImageAttachment,
-                reason: 'vision:requires-tool+image'
+                triggered: features.hasImageAttachment,
+                reason: 'vision:image-detected'
+            },
+            thinking: {
+                triggered: latestMessageFromUser,
+                reason: 'thinking:user-input'
             },
             longcontext: {
                 triggered: reachedLongContext,
                 reason: 'longcontext:token-threshold'
             },
-            websearch: {
-                triggered: features.hasWebTool || searchContinuation,
-                reason: searchContinuation ? 'websearch:last-tool-search' : 'websearch:web-tools-detected'
-            },
             coding: {
                 triggered: codingContinuation,
                 reason: 'coding:last-tool-write'
             },
-            thinking: {
-                triggered: thinkingContinuation || thinkingKeywordHit,
-                reason: thinkingContinuation ? 'thinking:last-tool-read' : 'thinking:keywords'
+            thinking_continuation: {
+                triggered: thinkingContinuation,
+                reason: 'thinking:last-tool-read'
             },
             tools: {
                 triggered: toolsContinuation || features.hasTools || features.hasToolCallResponses,

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/context-advisor.d.ts

@@ -0,0 +1,19 @@
+import { type ProviderProfile, type VirtualRouterContextRoutingConfig } from './types.js';
+export interface ContextUsageSnapshot {
+    ratio: number;
+    limit: number;
+}
+export interface ContextAdvisorResult {
+    safe: string[];
+    risky: string[];
+    overflow: string[];
+    usage: Record<string, ContextUsageSnapshot>;
+    estimatedTokens: number;
+    allOverflow: boolean;
+}
+export declare class ContextAdvisor {
+    private warnRatio;
+    private hardLimit;
+    configure(config?: VirtualRouterContextRoutingConfig | null): void;
+    classify(pool: string[], estimatedTokens: number, resolveProfile: (key: string) => ProviderProfile): ContextAdvisorResult;
+}

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

@@ -0,0 +1,64 @@
+import { DEFAULT_MODEL_CONTEXT_TOKENS } from './types.js';
+const DEFAULT_WARN_RATIO = 0.9;
+export class ContextAdvisor {
+    warnRatio = DEFAULT_WARN_RATIO;
+    hardLimit = false;
+    configure(config) {
+        if (config && typeof config.warnRatio === 'number' && Number.isFinite(config.warnRatio)) {
+            this.warnRatio = clampWarnRatio(config.warnRatio);
+        }
+        else {
+            this.warnRatio = DEFAULT_WARN_RATIO;
+        }
+        this.hardLimit = Boolean(config?.hardLimit);
+    }
+    classify(pool, estimatedTokens, resolveProfile) {
+        const normalizedTokens = typeof estimatedTokens === 'number' && Number.isFinite(estimatedTokens) && estimatedTokens > 0
+            ? estimatedTokens
+            : 0;
+        const safe = [];
+        const risky = [];
+        const overflow = [];
+        const usage = {};
+        for (const providerKey of pool) {
+            let limit = DEFAULT_MODEL_CONTEXT_TOKENS;
+            try {
+                const profile = resolveProfile(providerKey);
+                if (profile?.maxContextTokens && Number.isFinite(profile.maxContextTokens)) {
+                    limit = profile.maxContextTokens;
+                }
+            }
+            catch {
+                limit = DEFAULT_MODEL_CONTEXT_TOKENS;
+            }
+            if (!limit || limit <= 0) {
+                limit = DEFAULT_MODEL_CONTEXT_TOKENS;
+            }
+            const ratio = limit > 0 ? normalizedTokens / limit : 0;
+            usage[providerKey] = { ratio, limit };
+            if (normalizedTokens === 0 || ratio < this.warnRatio) {
+                safe.push(providerKey);
+                continue;
+            }
+            if (ratio < 1) {
+                risky.push(providerKey);
+                continue;
+            }
+            overflow.push(providerKey);
+        }
+        return {
+            safe,
+            risky,
+            overflow,
+            usage,
+            estimatedTokens: normalizedTokens,
+            allOverflow: safe.length === 0 && risky.length === 0 && overflow.length > 0
+        };
+    }
+}
+function clampWarnRatio(value) {
+    if (!Number.isFinite(value)) {
+        return DEFAULT_WARN_RATIO;
+    }
+    return Math.max(0.1, Math.min(0.99, value));
+}

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/engine.d.ts

@@ -6,9 +6,13 @@ export declare class VirtualRouterEngine {
     private readonly healthManager;
     private loadBalancer;
     private classifier;
+    private readonly contextAdvisor;
+    private contextRouting;
     private routeStats;
     private readonly debug;
     private healthConfig;
+    private readonly statsCenter;
+    private webSearchForce;
     initialize(config: VirtualRouterConfig): void;
     route(request: StandardizedRequest | ProcessedRequest, metadata: RouterMetadataInput): {
         target: TargetMetadata;
@@ -25,15 +29,37 @@ export declare class VirtualRouterEngine {
         }>;
         health: import("./types.js").ProviderHealthState[];
     };
+    /**
+     * 将分类器产生的逻辑路由名直接归一化为配置中的路由键。
+     * 不再维护 "websearch" 之类的别名，调用方应显式使用 "web_search" 或 "search" 等实际路由名。
+     */
+    private normalizeRouteAlias;
     private validateConfig;
     private selectProvider;
+    private trySelectFromTier;
     private incrementRouteStat;
     private providerHealthConfig;
+    private initializeRouteQueue;
+    private buildContextCandidatePools;
+    private describeAttempt;
     private resolveStickyKey;
     private mapProviderError;
     private deriveReason;
     private buildRouteCandidates;
+    private reorderForInlineVision;
+    private routeSupportsInlineVision;
     private sortByPriority;
     private routeWeight;
+    private routeHasForceFlag;
+    private routeHasTargets;
+    private hasPrimaryPool;
+    private sortRoutePools;
+    private flattenPoolTargets;
     private buildHitReason;
+    private decorateWithDetail;
+    private formatVirtualRouterHit;
+    private resolveRouteColor;
+    private describeContextUsage;
+    private describeTargetProvider;
+    private parseProviderKey;
 }