@jsonstudio/llms 0.6.567 → 0.6.586

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

@@ -8,14 +8,7 @@ const READ_TOOL_EXACT = new Set([
     'open_file',
     'get_file',
     'download_file',
-    'describe_current_request',
-    'list_dir',
-    'list_directory',
-    'list_files',
-    'list_documents',
-    'list_resources',
-    'search_files',
-    'find_files'
+    'describe_current_request'
 ]);
 const WRITE_TOOL_EXACT = new Set([
     'apply_patch',
@@ -26,83 +19,61 @@ const WRITE_TOOL_EXACT = new Set([
     'update_file',
     'save_file',
     'append_file',
-    'replace_file',
-    'delete_file',
-    'remove_file',
-    'rename_file',
-    'move_file',
-    'copy_file',
-    'mkdir',
-    'rmdir'
+    'replace_file'
+]);
+const SEARCH_TOOL_EXACT = new Set([
+    'search_files',
+    'find_files',
+    'search_documents',
+    'search_repo',
+    'glob_search',
+    'grep_files',
+    'code_search',
+    'lookup_symbol'
 ]);
-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 READ_TOOL_KEYWORDS = ['read', 'view', 'download', 'open', 'show', 'fetch', 'inspect'];
+const WRITE_TOOL_KEYWORDS = ['write', 'patch', 'modify', 'edit', 'create', 'update', 'append', 'replace', 'save'];
+const SEARCH_TOOL_KEYWORDS = ['find', 'grep', 'glob', 'lookup', 'locate'];
 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_READ_PATTERNS = [
-    'ls',
-    'dir ',
-    'pwd',
-    'cat ',
-    'type ',
-    'head ',
-    'tail ',
-    'stat',
-    'tree',
-    'wc ',
-    'du ',
-    'printf "',
-    'python - <<',
-    'python -c',
-    'node - <<',
-    'node -e'
-];
+const SHELL_WRITE_COMMANDS = new Set(['apply_patch', 'tee', 'touch', 'truncate', 'patch']);
+const SHELL_READ_COMMANDS = new Set(['cat', 'head', 'tail', 'awk', 'strings', 'less', 'more', 'nl']);
+const SHELL_SEARCH_COMMANDS = new Set([
+    'rg',
+    'ripgrep',
+    'grep',
+    'egrep',
+    'fgrep',
+    'ag',
+    'ack',
+    'find',
+    'fd',
+    'locate',
+    'codesearch'
+]);
+const SHELL_REDIRECT_WRITE_BINARIES = new Set(['cat', 'printf', 'python', 'node', 'perl', 'ruby', 'php', 'bash', 'sh', 'zsh', 'echo']);
+const SHELL_WRAPPER_COMMANDS = new Set(['sudo', 'env', 'time', 'nice', 'nohup', 'command', 'stdbuf']);
+const COMMAND_ALIASES = new Map([
+    ['python3', 'python'],
+    ['pip3', 'pip'],
+    ['ripgrep', 'rg'],
+    ['perl5', 'perl']
+]);
+const GIT_WRITE_SUBCOMMANDS = new Set(['add', 'commit', 'apply', 'am', 'rebase', 'checkout', 'merge']);
+const PACKAGE_MANAGER_COMMANDS = new Map([
+    ['npm', new Set(['install'])],
+    ['pnpm', new Set(['install'])],
+    ['yarn', new Set(['add', 'install'])],
+    ['pip', new Set(['install'])],
+    ['pip3', new Set(['install'])],
+    ['brew', new Set(['install'])],
+    ['cargo', new Set(['add', 'install'])],
+    ['go', new Set(['install'])],
+    ['make', new Set(['install'])]
+]);
+const ENV_ASSIGNMENT_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*=.*/;
+const OUTPUT_REDIRECT_PATTERN = /(?:^|[\s;|&])>>?\s*(?!&)[^\s]+/;
 export function detectVisionTool(request) {
     if (!Array.isArray(request.tools)) {
         return false;
@@ -160,31 +131,46 @@ export function extractMeaningfulDeclaredToolNames(tools) {
     }
     return names;
 }
+const TOOL_CATEGORY_PRIORITY = {
+    websearch: 4,
+    read: 3,
+    write: 2,
+    search: 1,
+    other: 0
+};
 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;
+        const candidates = [];
         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 (classification) {
+                candidates.push(classification);
             }
         }
-        if (fallback) {
-            return fallback;
+        if (!candidates.length) {
+            continue;
+        }
+        let best = candidates[0];
+        let bestScore = TOOL_CATEGORY_PRIORITY[best.category] ?? 0;
+        for (let i = 1; i < candidates.length; i += 1) {
+            const candidate = candidates[i];
+            const score = TOOL_CATEGORY_PRIORITY[candidate.category] ?? 0;
+            if (score > bestScore) {
+                best = candidate;
+                bestScore = score;
+            }
         }
+        return best;
     }
     return undefined;
 }
+export function classifyToolCallForReport(call) {
+    return classifyToolCall(call);
+}
 function classifyToolCall(call) {
     if (!call || typeof call !== 'object') {
         return undefined;
@@ -197,21 +183,48 @@ function classifyToolCall(call) {
     }
     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 normalizedName = functionName.toLowerCase();
+    const normalizedCmd = commandText.toLowerCase();
+    // 1) Web search 优先：函数名命中 web 搜索关键字时，一律归类为 websearch，优先级最高。
+    const isWebSearch = WEB_TOOL_KEYWORDS.some((keyword) => normalizedName.includes(keyword));
+    // 2) 基于工具名的初步分类（read / write / search / other）
+    const nameCategory = categorizeToolName(functionName);
+    // 3) shell_command / exec_command 根据内部命令判断读写性质
+    let shellCategory = 'other';
+    if (SHELL_TOOL_NAMES.has(functionName) || functionName === 'exec_command') {
+        shellCategory = classifyShellCommand(commandText);
+    }
+    // 按优先级合并分类结果：
+    //   1. web search
+    //   2. 写文件（任一维度命中写）
+    //   3. 读文件（任一维度命中读）
+    //   4. 其他搜索（非 web search）
+    //   5. 其它工具
+    // Priority 1: Web search
+    if (isWebSearch) {
+        return { category: 'websearch', name: functionName, commandSnippet: snippet };
+    }
+    // Priority 2: Write (写文件) — 名称或内部命令任一判断为写，都按写处理
+    if (nameCategory === 'write' || shellCategory === 'write') {
+        return { category: 'write', name: functionName, commandSnippet: snippet };
+    }
+    // Priority 3: Read (读文件) — 仅在没有写的情况下，再看读
+    if (nameCategory === 'read' || shellCategory === 'read') {
+        return { category: 'read', name: functionName, commandSnippet: snippet };
+    }
+    // Priority 4: 其他 search 类工具（非 web search）
+    if (nameCategory === 'search' || shellCategory === 'search') {
+        return { category: 'search', name: functionName, commandSnippet: snippet };
+    }
+    // Priority 5: 兜底用命令文本再判断一次 shell 风格读写/搜索（非 shell/exec_command 的工具）
+    if (!SHELL_TOOL_NAMES.has(functionName) && functionName !== 'exec_command' && commandText) {
         const derivedCategory = classifyShellCommand(commandText);
-        if (derivedCategory !== 'other') {
+        if (derivedCategory === 'write' || derivedCategory === 'read' || derivedCategory === 'search') {
             return { category: derivedCategory, name: functionName, commandSnippet: snippet };
         }
     }
+    // 最终兜底：other
     return { category: 'other', name: functionName, commandSnippet: snippet };
 }
 function extractToolName(tool) {
@@ -325,12 +338,10 @@ function categorizeToolName(name) {
         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()))) {
+    if (READ_TOOL_EXACT.has(normalized)) {
         return 'read';
     }
-    if (WRITE_TOOL_EXACT.has(normalized) ||
-        WRITE_TOOL_KEYWORDS.some((keyword) => normalized.includes(keyword.toLowerCase()))) {
+    if (WRITE_TOOL_EXACT.has(normalized)) {
         return 'write';
     }
     return 'other';
@@ -342,28 +353,225 @@ function classifyShellCommand(command) {
     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';
+    const segments = splitCommandSegments(command);
+    let sawRead = false;
+    let sawSearch = false;
+    for (const segment of segments) {
+        const normalized = normalizeShellSegment(segment);
+        if (!normalized) {
+            continue;
+        }
+        for (const args of normalized.commands) {
+            if (!args.length) {
+                continue;
+            }
+            const [binary, ...rest] = args;
+            const normalizedBinary = normalizeBinaryName(binary);
+            const alias = COMMAND_ALIASES.get(normalizedBinary) || normalizedBinary;
+            if (isWriteBinary(alias, rest, normalized.raw)) {
+                return 'write';
+            }
+            if (isReadBinary(alias, rest)) {
+                sawRead = true;
+                continue;
+            }
+            if (isSearchBinary(alias, rest)) {
+                sawSearch = true;
+            }
+        }
     }
-    if (segments.some((segment) => matchesAnyPattern(segment, SHELL_READ_PATTERNS))) {
+    if (sawRead) {
         return 'read';
     }
-    const stripped = stripShellWrapper(command);
-    if (matchesAnyPattern(stripped, SHELL_WRITE_PATTERNS)) {
-        return 'write';
-    }
-    if (matchesAnyPattern(stripped, SHELL_READ_PATTERNS)) {
-        return 'read';
+    if (sawSearch) {
+        return 'search';
     }
     return 'other';
 }
+function normalizeShellSegment(segment) {
+    const trimmed = stripShellWrapper(segment);
+    if (!trimmed) {
+        return undefined;
+    }
+    const tokens = splitShellTokens(trimmed);
+    if (!tokens.length) {
+        return undefined;
+    }
+    const commands = [];
+    let current = [];
+    for (const token of tokens) {
+        if (token === '|') {
+            const cleaned = cleanCommandTokens(current);
+            if (cleaned.length) {
+                commands.push(cleaned);
+            }
+            current = [];
+            continue;
+        }
+        current.push(token);
+    }
+    const cleaned = cleanCommandTokens(current);
+    if (cleaned.length) {
+        commands.push(cleaned);
+    }
+    if (!commands.length) {
+        return undefined;
+    }
+    return { raw: trimmed, commands };
+}
+function splitShellTokens(cmd) {
+    const tokens = [];
+    let current = '';
+    let quote = null;
+    for (let i = 0; i < cmd.length; i += 1) {
+        const ch = cmd[i];
+        if (quote) {
+            if (ch === quote) {
+                quote = null;
+            }
+            else if (ch === '\\' && quote === '"' && i + 1 < cmd.length) {
+                current += cmd[i + 1];
+                i += 1;
+            }
+            else {
+                current += ch;
+            }
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            continue;
+        }
+        if (/[\s\t]/.test(ch)) {
+            if (current) {
+                tokens.push(current);
+                current = '';
+            }
+            continue;
+        }
+        if (ch === '|') {
+            if (current) {
+                tokens.push(current);
+                current = '';
+            }
+            tokens.push('|');
+            continue;
+        }
+        if ((ch === '|' || ch === '&') && i + 1 < cmd.length && cmd[i + 1] === ch) {
+            if (current) {
+                tokens.push(current);
+                current = '';
+            }
+            tokens.push(cmd.slice(i, i + 2));
+            i += 1;
+            continue;
+        }
+        current += ch;
+    }
+    if (current) {
+        tokens.push(current);
+    }
+    return tokens;
+}
+function cleanCommandTokens(tokens) {
+    if (!tokens.length) {
+        return [];
+    }
+    const cleaned = [];
+    for (const token of tokens) {
+        if (!cleaned.length) {
+            if (ENV_ASSIGNMENT_PATTERN.test(token)) {
+                continue;
+            }
+            if (SHELL_WRAPPER_COMMANDS.has(token)) {
+                continue;
+            }
+        }
+        cleaned.push(token);
+    }
+    return cleaned;
+}
+function isWriteBinary(binary, args, rawSegment) {
+    const normalized = binary.toLowerCase();
+    if (SHELL_WRITE_COMMANDS.has(normalized)) {
+        return true;
+    }
+    if (normalized === 'git' && args.length > 0) {
+        const sub = args[0].toLowerCase();
+        if (GIT_WRITE_SUBCOMMANDS.has(sub)) {
+            return true;
+        }
+    }
+    if (PACKAGE_MANAGER_COMMANDS.has(normalized)) {
+        const allowed = PACKAGE_MANAGER_COMMANDS.get(normalized);
+        if (args.length > 0 && allowed.has(args[0].toLowerCase())) {
+            return true;
+        }
+    }
+    if (normalized === 'sed') {
+        const joined = args.join(' ').toLowerCase();
+        if (joined.includes('-i')) {
+            return true;
+        }
+    }
+    if (normalized === 'perl') {
+        const joined = args.join(' ').toLowerCase();
+        if (joined.includes('-pi')) {
+            return true;
+        }
+    }
+    if (normalized === 'printf' && OUTPUT_REDIRECT_PATTERN.test(rawSegment)) {
+        return true;
+    }
+    if (SHELL_REDIRECT_WRITE_BINARIES.has(normalized) && OUTPUT_REDIRECT_PATTERN.test(rawSegment)) {
+        return true;
+    }
+    return false;
+}
+function isReadBinary(binary, args) {
+    const normalized = binary.toLowerCase();
+    if (SHELL_READ_COMMANDS.has(normalized)) {
+        return true;
+    }
+    if (normalized === 'sed') {
+        const joined = args.join(' ').toLowerCase();
+        if (joined.includes('-i')) {
+            return false;
+        }
+        return true;
+    }
+    return false;
+}
+function isSearchBinary(binary, args) {
+    const normalized = binary.toLowerCase();
+    if (SHELL_SEARCH_COMMANDS.has(normalized)) {
+        return true;
+    }
+    if (normalized === 'git' && args.length > 0) {
+        const sub = args[0].toLowerCase();
+        if (sub === 'grep') {
+            return true;
+        }
+    }
+    return false;
+}
 function splitCommandSegments(command) {
     return command
         .split(/(?:\r?\n|&&|\|\||;)/)
         .map((segment) => segment.trim())
         .filter(Boolean);
 }
+function normalizeBinaryName(binary) {
+    if (!binary) {
+        return '';
+    }
+    const lowered = binary.toLowerCase();
+    const slashIndex = lowered.lastIndexOf('/');
+    if (slashIndex >= 0) {
+        return lowered.slice(slashIndex + 1);
+    }
+    return lowered;
+}
 function stripShellWrapper(command) {
     if (!command) {
         return '';
@@ -376,6 +584,3 @@ function stripShellWrapper(command) {
     }
     return command.trim();
 }
-function matchesAnyPattern(command, patterns) {
-    return patterns.some((pattern) => command.includes(pattern));
-}

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

@@ -172,6 +172,11 @@ export interface RouterMetadataInput {
      * 强制路由模式，从消息中的 <**...**> 指令解析得出
      */
     routingMode?: RoutingInstructionMode;
+    /**
+     * 当 disableStickyRoutes=true 时，本次请求仍使用 sticky session 状态，
+     * 但不继承 sticky target，允许后续路由重新选择 provider。
+     */
+    disableStickyRoutes?: boolean;
     /**
      * 允许的 provider 白名单
      */
@@ -228,7 +233,7 @@ export interface RoutingFeatures {
     hasCodingTool: boolean;
     hasThinkingKeyword: boolean;
     estimatedTokens: number;
-    lastAssistantToolCategory?: 'read' | 'write' | 'search' | 'other';
+    lastAssistantToolCategory?: 'read' | 'write' | 'search' | 'websearch' | 'other';
     lastAssistantToolSnippet?: string;
     lastAssistantToolLabel?: string;
     latestMessageFromUser?: boolean;
@@ -343,3 +348,28 @@ export interface ProviderErrorEvent {
 export interface FeatureBuilder {
     build(request: StandardizedRequest, metadata: RouterMetadataInput): RoutingFeatures;
 }
+export interface ProviderCooldownState {
+    providerKey: string;
+    cooldownExpiresAt: number;
+    reason?: string;
+}
+export interface VirtualRouterHealthSnapshot {
+    providers: ProviderHealthState[];
+    cooldowns: ProviderCooldownState[];
+}
+export interface VirtualRouterHealthStore {
+    /**
+     * 在 VirtualRouterEngine 初始化时提供上一次持久化的健康快照。
+     * 调用方应仅返回仍在有效期内的 cooldown/熔断信息，或返回 null 表示无可恢复状态。
+     */
+    loadInitialSnapshot(): VirtualRouterHealthSnapshot | null;
+    /**
+     * 当 VirtualRouterEngine 更新 provider 健康状态或 cooldown 时，可选地持久化最新快照。
+     * 实现应保证内部吞掉 I/O 错误，不影响路由主流程。
+     */
+    persistSnapshot?(snapshot: VirtualRouterHealthSnapshot): void;
+    /**
+     * 可选：记录原始 ProviderErrorEvent，便于后续离线统计与诊断。
+     */
+    recordProviderError?(event: ProviderErrorEvent): void;
+}

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

@@ -7,9 +7,9 @@ export const ROUTE_PRIORITY = [
     'vision',
     'longcontext',
     'web_search',
-    'search',
-    'coding',
     'thinking',
+    'coding',
+    'search',
     'tools',
     'background',
     DEFAULT_ROUTE

package/dist/servertool/engine.js

@@ -94,6 +94,9 @@ function resolveRouteHint(adapterContext, flowId) {
     if (!routeId) {
         return undefined;
     }
+    if (routeId.toLowerCase() === 'default') {
+        return undefined;
+    }
     if (flowId && routeId.toLowerCase() === flowId.toLowerCase()) {
         return undefined;
     }

package/dist/servertool/handlers/iflow-model-error-retry.d.ts

@@ -0,0 +1 @@
+export {};