@jsonstudio/llms 0.6.147 → 0.6.198

package/dist/router/virtual-router/message-utils.js

@@ -0,0 +1,66 @@
+export function getLatestUserMessage(messages) {
+    for (let idx = messages.length - 1; idx >= 0; idx -= 1) {
+        if (messages[idx]?.role === 'user') {
+            return messages[idx];
+        }
+    }
+    return undefined;
+}
+export function getLatestMessageRole(messages) {
+    if (!Array.isArray(messages) || !messages.length) {
+        return undefined;
+    }
+    const last = messages[messages.length - 1];
+    if (last && typeof last.role === 'string' && last.role.trim()) {
+        return last.role.trim();
+    }
+    return undefined;
+}
+export function extractMessageText(message) {
+    if (typeof message.content === 'string' && message.content.trim()) {
+        return message.content;
+    }
+    return '';
+}
+export function detectKeyword(text, keywords) {
+    if (!text)
+        return false;
+    return keywords.some((keyword) => text.includes(keyword.toLowerCase()));
+}
+export function detectExtendedThinkingKeyword(text) {
+    if (!text) {
+        return false;
+    }
+    const keywords = ['仔细分析', '思考', '超级思考', '深度思考', 'careful analysis', 'deep thinking', 'deliberate'];
+    return keywords.some((keyword) => text.includes(keyword));
+}
+export function detectImageAttachment(message) {
+    if (!message)
+        return false;
+    if (!message.metadata || typeof message.metadata !== 'object') {
+        return false;
+    }
+    const meta = message.metadata;
+    const attachments = (meta.attachments ?? null);
+    if (Array.isArray(attachments)) {
+        return attachments.some((attachment) => {
+            const candidate = attachment;
+            const typeValue = typeof candidate.type === 'string' ? candidate.type.toLowerCase() : '';
+            const urlValue = typeof candidate.url === 'string'
+                ? candidate.url
+                : typeof candidate.src === 'string'
+                    ? candidate.src
+                    : typeof candidate.image_url === 'string'
+                        ? candidate.image_url
+                        : typeof candidate.image_url?.url === 'string'
+                            ? candidate.image_url.url
+                            : '';
+            return typeValue.includes('image') && urlValue.trim().length > 0;
+        });
+    }
+    if (typeof meta.attachmentType === 'string' && meta.attachmentType.toLowerCase().includes('image')) {
+        const urlCandidate = typeof meta.attachmentUrl === 'string' ? meta.attachmentUrl : '';
+        return urlCandidate.trim().length > 0;
+    }
+    return false;
+}

package/dist/router/virtual-router/provider-registry.js

@@ -42,7 +42,9 @@ export class ProviderRegistry {
             runtimeKey: profile.runtimeKey,
             modelId,
             processMode: profile.processMode || 'chat',
-            responsesConfig: profile.responsesConfig
+            responsesConfig: profile.responsesConfig,
+            streaming: profile.streaming,
+            maxContextTokens: profile.maxContextTokens
         };
     }
     static normalizeProfile(key, profile) {
@@ -58,7 +60,9 @@ export class ProviderRegistry {
             runtimeKey: profile.runtimeKey,
             modelId,
             processMode: profile.processMode || 'chat',
-            responsesConfig: profile.responsesConfig
+            responsesConfig: profile.responsesConfig,
+            streaming: profile.streaming,
+            maxContextTokens: profile.maxContextTokens
         };
     }
 }

package/dist/router/virtual-router/token-estimator.d.ts

@@ -0,0 +1,2 @@
+import type { ProcessedRequest, StandardizedRequest } from '../../conversion/hub/types/standardized.js';
+export declare function computeRequestTokens(request: StandardizedRequest | ProcessedRequest, fallbackText: string): number;

package/dist/router/virtual-router/token-estimator.js

@@ -0,0 +1,16 @@
+import { countRequestTokens } from './token-counter.js';
+export function computeRequestTokens(request, fallbackText) {
+    try {
+        return countRequestTokens(request);
+    }
+    catch {
+        return fallbackEstimateTokens(fallbackText, request.messages?.length ?? 0);
+    }
+}
+function fallbackEstimateTokens(text, messageCount) {
+    if (!text) {
+        return Math.max(32, Math.max(messageCount, 1) * 16);
+    }
+    const rough = Math.ceil(text.length / 4);
+    return Math.max(rough, Math.max(messageCount, 1) * 32);
+}

package/dist/router/virtual-router/token-file-scanner.d.ts

@@ -0,0 +1,15 @@
+export interface OAuthTokenFileMatch {
+    filePath: string;
+    sequence: number;
+    alias: string;
+}
+/**
+ * 扫描本地 RouteCodex auth 目录中的 OAuth token 文件。
+ *
+ * 约定:
+ * - 目录: ~/.routecodex/auth
+ * - 文件名: <provider>-oauth-<sequence>[-<alias>].json
+ *
+ * 仅在 Node 环境下使用；如果环境不满足，返回空列表。
+ */
+export declare function scanOAuthTokenFiles(oauthProviderId: string, authDir?: string): OAuthTokenFileMatch[];

package/dist/router/virtual-router/token-file-scanner.js

@@ -0,0 +1,56 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+const TOKEN_FILE_PATTERN = /^([a-z0-9_-]+)-oauth-(\d+)(?:-(.+))?\.json$/i;
+/**
+ * 扫描本地 RouteCodex auth 目录中的 OAuth token 文件。
+ *
+ * 约定:
+ * - 目录: ~/.routecodex/auth
+ * - 文件名: <provider>-oauth-<sequence>[-<alias>].json
+ *
+ * 仅在 Node 环境下使用；如果环境不满足，返回空列表。
+ */
+export function scanOAuthTokenFiles(oauthProviderId, authDir) {
+    if (!isNodeEnvironment()) {
+        return [];
+    }
+    const provider = oauthProviderId.trim().toLowerCase();
+    if (!provider) {
+        return [];
+    }
+    const baseDir = authDir && authDir.trim()
+        ? authDir.trim()
+        : path.join(os.homedir(), '.routecodex', 'auth');
+    let entries;
+    try {
+        entries = fs.readdirSync(baseDir);
+    }
+    catch {
+        return [];
+    }
+    const matches = [];
+    for (const entry of entries) {
+        if (!entry.endsWith('.json'))
+            continue;
+        const match = entry.match(TOKEN_FILE_PATTERN);
+        if (!match)
+            continue;
+        const [, providerPrefix, sequenceStr, alias] = match;
+        if (providerPrefix.toLowerCase() !== provider)
+            continue;
+        const sequence = parseInt(sequenceStr, 10);
+        if (!Number.isFinite(sequence) || sequence <= 0)
+            continue;
+        matches.push({
+            filePath: path.join(baseDir, entry),
+            sequence,
+            alias: alias || 'default'
+        });
+    }
+    matches.sort((a, b) => a.sequence - b.sequence);
+    return matches;
+}
+function isNodeEnvironment() {
+    return typeof process !== 'undefined' && !!process.release && process.release.name === 'node';
+}

package/dist/router/virtual-router/tool-signals.d.ts

@@ -0,0 +1,13 @@
+import type { StandardizedMessage, StandardizedRequest } from '../../conversion/hub/types/standardized.js';
+export type ToolCategory = 'read' | 'write' | 'search' | 'other';
+export type ToolClassification = {
+    category: ToolCategory;
+    name: string;
+    commandSnippet?: string;
+};
+export declare function detectVisionTool(request: StandardizedRequest): boolean;
+export declare function detectCodingTool(request: StandardizedRequest): boolean;
+export declare function detectWebTool(request: StandardizedRequest): boolean;
+export declare function extractMeaningfulDeclaredToolNames(tools: StandardizedRequest['tools'] | undefined): string[];
+export declare function detectLastAssistantToolCategory(messages: StandardizedMessage[]): ToolClassification | undefined;
+export declare function canonicalizeToolName(rawName: string): string;

package/dist/router/virtual-router/tool-signals.js

@@ -0,0 +1,403 @@
+const WEB_TOOL_KEYWORDS = ['websearch', 'web_search', 'web-search', 'webfetch', 'web_fetch', 'web_request', 'search_web', 'internet_search'];
+const READ_TOOL_EXACT = new Set([
+    'read_file',
+    'read_text',
+    'view_file',
+    'view_code',
+    'view_document',
+    'open_file',
+    'get_file',
+    'download_file',
+    'describe_current_request',
+    'list_dir',
+    'list_directory',
+    'list_files',
+    'list_documents',
+    'list_resources',
+    'search_files',
+    'find_files'
+]);
+const WRITE_TOOL_EXACT = new Set([
+    'apply_patch',
+    'write_file',
+    'create_file',
+    'modify_file',
+    'edit_file',
+    'update_file',
+    'save_file',
+    'append_file',
+    'replace_file',
+    'delete_file',
+    'remove_file',
+    'rename_file',
+    'move_file',
+    'copy_file',
+    'mkdir',
+    'rmdir'
+]);
+const SEARCH_TOOL_EXACT = new Set(['websearch', 'web_search', 'search_web', 'internet_search', 'webfetch', 'web_fetch']);
+const READ_TOOL_KEYWORDS = ['read', 'list', 'view', 'download', 'open', 'show', 'fetch', 'inspect'];
+const WRITE_TOOL_KEYWORDS = ['write', 'patch', 'modify', 'edit', 'create', 'update', 'append', 'replace', 'delete', 'remove'];
+const SEARCH_TOOL_KEYWORDS = ['search', 'websearch', 'web_fetch', 'webfetch', 'web-request', 'web_request', 'internet'];
+const SHELL_TOOL_NAMES = new Set(['shell_command', 'shell', 'bash']);
+const DECLARED_TOOL_IGNORE = new Set(['exec_command']);
+const SHELL_HEREDOC_PATTERN = /<<\s*['"]?[a-z0-9_-]+/i;
+const SHELL_WRITE_PATTERNS = [
+    'apply_patch',
+    'sed -i',
+    'perl -pi',
+    'tee ',
+    'cat <<',
+    'cat >',
+    'printf >',
+    'touch ',
+    'truncate',
+    'mkdir',
+    'mktemp',
+    'rmdir',
+    'rm ',
+    'rm-',
+    'unlink',
+    'mv ',
+    'cp ',
+    'ln -',
+    'chmod',
+    'chown',
+    'chgrp',
+    'tar ',
+    'git add',
+    'git commit',
+    'git apply',
+    'git am',
+    'git rebase',
+    'git checkout',
+    'git merge',
+    'patch <<',
+    'npm install',
+    'pnpm install',
+    'yarn add',
+    'yarn install',
+    'pip install',
+    'pip3 install',
+    'brew install',
+    'cargo add',
+    'cargo install',
+    'go install',
+    'make install'
+];
+const SHELL_SEARCH_PATTERNS = [
+    'rg ',
+    'rg-',
+    'grep ',
+    'grep-',
+    'ripgrep',
+    'find ',
+    'fd ',
+    'locate ',
+    'search ',
+    'ack ',
+    'ag ',
+    'where ',
+    'which ',
+    'codesearch'
+];
+const SHELL_READ_PATTERNS = [
+    'ls',
+    'dir ',
+    'pwd',
+    'cat ',
+    'type ',
+    'head ',
+    'tail ',
+    'stat',
+    'tree',
+    'wc ',
+    'du ',
+    'printf "',
+    'python - <<',
+    'python -c',
+    'node - <<',
+    'node -e'
+];
+export function detectVisionTool(request) {
+    if (!Array.isArray(request.tools)) {
+        return false;
+    }
+    return request.tools.some((tool) => {
+        const functionName = extractToolName(tool);
+        const description = extractToolDescription(tool);
+        return /vision|image|picture|photo/i.test(functionName) || /vision|image|picture|photo/i.test(description || '');
+    });
+}
+export function detectCodingTool(request) {
+    if (!Array.isArray(request.tools)) {
+        return false;
+    }
+    return request.tools.some((tool) => {
+        const functionName = extractToolName(tool).toLowerCase();
+        const description = (extractToolDescription(tool) || '').toLowerCase();
+        if (!functionName && !description) {
+            return false;
+        }
+        if (WRITE_TOOL_EXACT.has(functionName)) {
+            return true;
+        }
+        return WRITE_TOOL_KEYWORDS.some((keyword) => functionName.includes(keyword.toLowerCase()) || description.includes(keyword.toLowerCase()));
+    });
+}
+export function detectWebTool(request) {
+    if (!Array.isArray(request.tools)) {
+        return false;
+    }
+    return request.tools.some((tool) => {
+        const functionName = extractToolName(tool);
+        const description = extractToolDescription(tool);
+        const normalizedName = functionName.toLowerCase();
+        const normalizedDesc = (description || '').toLowerCase();
+        return (WEB_TOOL_KEYWORDS.some((keyword) => normalizedName.includes(keyword)) ||
+            WEB_TOOL_KEYWORDS.some((keyword) => normalizedDesc.includes(keyword)));
+    });
+}
+export function extractMeaningfulDeclaredToolNames(tools) {
+    if (!Array.isArray(tools) || tools.length === 0) {
+        return [];
+    }
+    const names = [];
+    for (const tool of tools) {
+        const rawName = extractToolName(tool);
+        if (!rawName) {
+            continue;
+        }
+        const canonical = canonicalizeToolName(rawName).toLowerCase();
+        if (!canonical || DECLARED_TOOL_IGNORE.has(canonical)) {
+            continue;
+        }
+        names.push(rawName);
+    }
+    return names;
+}
+export function detectLastAssistantToolCategory(messages) {
+    for (let idx = messages.length - 1; idx >= 0; idx -= 1) {
+        const msg = messages[idx];
+        if (!msg || !Array.isArray(msg.tool_calls) || msg.tool_calls.length === 0) {
+            continue;
+        }
+        let fallback;
+        for (const call of msg.tool_calls) {
+            const classification = classifyToolCall(call);
+            if (!classification) {
+                continue;
+            }
+            if (!fallback) {
+                fallback = classification;
+            }
+            if (classification.category !== 'other') {
+                return classification;
+            }
+        }
+        if (fallback) {
+            return fallback;
+        }
+    }
+    return undefined;
+}
+function classifyToolCall(call) {
+    if (!call || typeof call !== 'object') {
+        return undefined;
+    }
+    const functionName = typeof call?.function?.name === 'string' && call.function.name.trim()
+        ? canonicalizeToolName(call.function.name)
+        : '';
+    if (!functionName) {
+        return undefined;
+    }
+    const argsObject = parseToolArguments(call?.function?.arguments);
+    const commandText = extractCommandText(argsObject);
+    const nameCategory = categorizeToolName(functionName);
+    const snippet = buildCommandSnippet(commandText);
+    if (nameCategory === 'write' || nameCategory === 'read' || nameCategory === 'search') {
+        return { category: nameCategory, name: functionName, commandSnippet: snippet };
+    }
+    if (SHELL_TOOL_NAMES.has(functionName)) {
+        const shellCategory = classifyShellCommand(commandText);
+        return { category: shellCategory, name: functionName, commandSnippet: snippet };
+    }
+    if (commandText) {
+        const derivedCategory = classifyShellCommand(commandText);
+        if (derivedCategory !== 'other') {
+            return { category: derivedCategory, name: functionName, commandSnippet: snippet };
+        }
+    }
+    return { category: 'other', name: functionName, commandSnippet: snippet };
+}
+function extractToolName(tool) {
+    if (!tool || typeof tool !== 'object') {
+        return '';
+    }
+    const candidate = tool;
+    const fromFunction = candidate.function;
+    if (fromFunction && typeof fromFunction.name === 'string' && fromFunction.name.trim()) {
+        return fromFunction.name;
+    }
+    if (typeof candidate.name === 'string' && candidate.name.trim()) {
+        return candidate.name;
+    }
+    return '';
+}
+function extractToolDescription(tool) {
+    if (!tool || typeof tool !== 'object') {
+        return '';
+    }
+    const candidate = tool;
+    const fromFunction = candidate.function;
+    if (fromFunction && typeof fromFunction.description === 'string' && fromFunction.description.trim()) {
+        return fromFunction.description;
+    }
+    if (typeof candidate.description === 'string' && candidate.description.trim()) {
+        return candidate.description;
+    }
+    return '';
+}
+export function canonicalizeToolName(rawName) {
+    const trimmed = rawName.trim();
+    const markerIndex = trimmed.indexOf('arg_');
+    if (markerIndex > 0) {
+        return trimmed.slice(0, markerIndex);
+    }
+    return trimmed;
+}
+function parseToolArguments(rawArguments) {
+    if (!rawArguments) {
+        return undefined;
+    }
+    if (typeof rawArguments === 'string') {
+        try {
+            return JSON.parse(rawArguments);
+        }
+        catch {
+            return rawArguments;
+        }
+    }
+    if (typeof rawArguments === 'object') {
+        return rawArguments;
+    }
+    return undefined;
+}
+function extractCommandText(args) {
+    if (!args) {
+        return '';
+    }
+    if (typeof args === 'string') {
+        return args;
+    }
+    if (Array.isArray(args)) {
+        return args.map((item) => (typeof item === 'string' ? item : '')).filter(Boolean).join(' ');
+    }
+    if (typeof args === 'object') {
+        const record = args;
+        const stringKeys = ['command', 'cmd', 'input', 'code', 'script', 'text', 'prompt'];
+        for (const key of stringKeys) {
+            const value = record[key];
+            if (typeof value === 'string' && value.trim()) {
+                return value;
+            }
+            if (Array.isArray(value)) {
+                const joined = value.map((item) => (typeof item === 'string' ? item : '')).filter(Boolean).join(' ');
+                if (joined.trim()) {
+                    return joined;
+                }
+            }
+        }
+        const nestedArgs = record.args;
+        if (typeof nestedArgs === 'string' && nestedArgs.trim()) {
+            return nestedArgs;
+        }
+        if (Array.isArray(nestedArgs)) {
+            const joined = nestedArgs.map((item) => (typeof item === 'string' ? item : '')).filter(Boolean).join(' ');
+            if (joined.trim()) {
+                return joined;
+            }
+        }
+    }
+    return '';
+}
+function buildCommandSnippet(commandText) {
+    if (!commandText) {
+        return undefined;
+    }
+    const collapsed = commandText.replace(/\s+/g, ' ').trim();
+    if (!collapsed) {
+        return undefined;
+    }
+    const limit = 80;
+    if (collapsed.length <= limit) {
+        return collapsed;
+    }
+    return `${collapsed.slice(0, limit)}…`;
+}
+function categorizeToolName(name) {
+    const normalized = name.toLowerCase();
+    if (SEARCH_TOOL_EXACT.has(normalized) ||
+        SEARCH_TOOL_KEYWORDS.some((keyword) => normalized.includes(keyword.toLowerCase()))) {
+        return 'search';
+    }
+    if (READ_TOOL_EXACT.has(normalized) ||
+        READ_TOOL_KEYWORDS.some((keyword) => normalized.includes(keyword.toLowerCase()))) {
+        return 'read';
+    }
+    if (WRITE_TOOL_EXACT.has(normalized) ||
+        WRITE_TOOL_KEYWORDS.some((keyword) => normalized.includes(keyword.toLowerCase()))) {
+        return 'write';
+    }
+    return 'other';
+}
+function classifyShellCommand(command) {
+    if (!command) {
+        return 'other';
+    }
+    if (SHELL_HEREDOC_PATTERN.test(command)) {
+        return 'write';
+    }
+    const segments = splitCommandSegments(command).map(stripShellWrapper);
+    if (segments.some((segment) => matchesAnyPattern(segment, SHELL_WRITE_PATTERNS))) {
+        return 'write';
+    }
+    if (segments.some((segment) => matchesAnyPattern(segment, SHELL_SEARCH_PATTERNS))) {
+        return 'search';
+    }
+    if (segments.some((segment) => matchesAnyPattern(segment, SHELL_READ_PATTERNS))) {
+        return 'read';
+    }
+    const stripped = stripShellWrapper(command);
+    if (matchesAnyPattern(stripped, SHELL_WRITE_PATTERNS)) {
+        return 'write';
+    }
+    if (matchesAnyPattern(stripped, SHELL_SEARCH_PATTERNS)) {
+        return 'search';
+    }
+    if (matchesAnyPattern(stripped, SHELL_READ_PATTERNS)) {
+        return 'read';
+    }
+    return 'other';
+}
+function splitCommandSegments(command) {
+    return command
+        .split(/(?:\r?\n|&&|\|\||;)/)
+        .map((segment) => segment.trim())
+        .filter(Boolean);
+}
+function stripShellWrapper(command) {
+    if (!command) {
+        return '';
+    }
+    const wrappers = ['bash -lc', 'sh -c', 'zsh -c'];
+    for (const wrapper of wrappers) {
+        if (command.startsWith(wrapper)) {
+            return command.slice(wrapper.length).trim();
+        }
+    }
+    return command.trim();
+}
+function matchesAnyPattern(command, patterns) {
+    return patterns.some((pattern) => command.includes(pattern));
+}

package/dist/router/virtual-router/types.d.ts

@@ -2,9 +2,11 @@
  * Virtual Router 类型定义
  */
 import type { StandardizedRequest } from '../../conversion/hub/types/standardized.js';
+export declare const DEFAULT_MODEL_CONTEXT_TOKENS = 200000;
 export declare const DEFAULT_ROUTE = "default";
 export declare const ROUTE_PRIORITY: string[];
 export type RoutingPools = Record<string, string[]>;
+export type StreamingPreference = 'auto' | 'always' | 'never';
 export interface ProviderAuthConfig {
     type: 'apiKey' | 'oauth';
     secretRef?: string;
@@ -32,6 +34,8 @@ export interface ProviderProfile {
     modelId?: string;
     processMode?: 'chat' | 'passthrough';
     responsesConfig?: ResponsesProviderConfig;
+    streaming?: StreamingPreference;
+    maxContextTokens?: number;
 }
 export interface ProviderRuntimeProfile {
     runtimeKey: string;
@@ -46,6 +50,11 @@ export interface ProviderRuntimeProfile {
     modelId?: string;
     processMode?: 'chat' | 'passthrough';
     responsesConfig?: ResponsesProviderConfig;
+    streaming?: StreamingPreference;
+    modelStreaming?: Record<string, StreamingPreference>;
+    modelContextTokens?: Record<string, number>;
+    defaultContextTokens?: number;
+    maxContextTokens?: number;
 }
 export interface VirtualRouterClassifierConfig {
     longContextThresholdTokens?: number;
@@ -69,6 +78,12 @@ export interface VirtualRouterConfig {
     classifier: VirtualRouterClassifierConfig;
     loadBalancing?: LoadBalancingPolicy;
     health?: ProviderHealthConfig;
+    contextRouting?: VirtualRouterContextRoutingConfig;
+}
+export interface VirtualRouterContextRoutingConfig {
+    warnRatio: number;
+    hardLimit?: boolean;
+    fallbackRoute?: string;
 }
 export type VirtualRouterProviderDefinition = Record<string, unknown>;
 export interface VirtualRouterBootstrapInput extends Record<string, unknown> {
@@ -78,6 +93,7 @@ export interface VirtualRouterBootstrapInput extends Record<string, unknown> {
     classifier?: VirtualRouterClassifierConfig;
     loadBalancing?: LoadBalancingPolicy;
     health?: ProviderHealthConfig;
+    contextRouting?: VirtualRouterContextRoutingConfig;
 }
 export type ProviderRuntimeMap = Record<string, ProviderRuntimeProfile>;
 export interface VirtualRouterBootstrapResult {
@@ -117,10 +133,9 @@ export interface RoutingFeatures {
     hasThinkingKeyword: boolean;
     estimatedTokens: number;
     lastAssistantToolCategory?: 'read' | 'write' | 'search' | 'other';
-    lastAssistantToolName?: string;
-    lastAssistantToolDetail?: string;
-    assistantToolCategories?: Array<'read' | 'write' | 'search' | 'other'>;
-    assistantCalledWebSearchTool?: boolean;
+    lastAssistantToolSnippet?: string;
+    lastAssistantToolLabel?: string;
+    latestMessageFromUser?: boolean;
     metadata: RouterMetadataInput;
 }
 export interface ClassificationResult {
@@ -147,12 +162,11 @@ export interface TargetMetadata {
     modelId: string;
     processMode?: 'chat' | 'passthrough';
     responsesConfig?: ResponsesProviderConfig;
+    streaming?: StreamingPreference;
+    maxContextTokens?: number;
 }
-export type ResponsesStreamingMode = 'auto' | 'always' | 'never';
 export interface ResponsesProviderConfig {
     toolCallIdStyle?: 'fc' | 'preserve';
-    streaming?: ResponsesStreamingMode;
-    instructionsMode?: 'default' | 'inline';
 }
 export declare enum VirtualRouterErrorCode {
     NO_STANDARDIZED_REQUEST = "NO_STANDARDIZED_REQUEST",

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

@@ -1,6 +1,7 @@
 /**
  * Virtual Router 类型定义
  */
+export const DEFAULT_MODEL_CONTEXT_TOKENS = 200_000;
 export const DEFAULT_ROUTE = 'default';
 export const ROUTE_PRIORITY = [
     'vision',