@jsonstudio/llms 0.6.147 → 0.6.187

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

@@ -1,114 +1,15 @@
-import { countRequestTokens } from './token-counter.js';
+import { detectExtendedThinkingKeyword, detectImageAttachment, detectKeyword, extractMessageText, getLatestMessageRole, getLatestUserMessage } from './message-utils.js';
+import { detectCodingTool, detectLastAssistantToolCategory, detectVisionTool, detectWebTool, extractMeaningfulDeclaredToolNames } from './tool-signals.js';
+import { computeRequestTokens } from './token-estimator.js';
 const THINKING_KEYWORDS = ['let me think', 'chain of thought', 'cot', 'reason step', 'deliberate'];
-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 SHELL_HEREDOC_PATTERN = /<<\s*['"]?[a-z0-9_-]+/i;
-const COMMAND_DETAIL_MAX_LENGTH = 80;
-const TOOL_CATEGORY_PRIORITY = ['search', 'write', 'read', 'other'];
-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 apply',
-    'git am',
-    'git checkout',
-    'git merge',
-    'patch <<'
-];
-const SHELL_SEARCH_PATTERNS = [
-    'rg ',
-    'rg-',
-    'grep ',
-    'grep-',
-    'ripgrep',
-    'find ',
-    'fd ',
-    'locate ',
-    'search ',
-    'ack ',
-    'ag ',
-    'where ',
-    'which ',
-    'codesearch'
-];
-const SHELL_READ_PATTERNS = [
-    'cat ',
-    'type ',
-    'head ',
-    'tail ',
-    'stat ',
-    'stat',
-    'wc ',
-    'python - <<',
-    'python -c',
-    'node - <<',
-    'node -e'
-];
 export function buildRoutingFeatures(request, metadata) {
     const latestUserMessage = getLatestUserMessage(request.messages);
+    const latestMessageRole = getLatestMessageRole(request.messages);
     const assistantMessages = request.messages.filter((msg) => msg.role === 'assistant');
     const latestUserText = latestUserMessage ? extractMessageText(latestUserMessage) : '';
     const normalizedUserText = latestUserText.toLowerCase();
-    const hasTools = Array.isArray(request.tools) && request.tools.length > 0;
+    const meaningfulDeclaredTools = extractMeaningfulDeclaredToolNames(request.tools);
+    const hasTools = meaningfulDeclaredTools.length > 0;
     const hasToolCallResponses = assistantMessages.some((msg) => Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0);
     const estimatedTokens = computeRequestTokens(request, latestUserText);
     const hasThinking = detectKeyword(normalizedUserText, THINKING_KEYWORDS);
@@ -117,13 +18,25 @@ export function buildRoutingFeatures(request, metadata) {
     const hasCodingTool = detectCodingTool(request);
     const hasWebTool = detectWebTool(request);
     const hasThinkingKeyword = hasThinking || detectExtendedThinkingKeyword(normalizedUserText);
-    const assistantToolSummary = summarizeAssistantToolUsage(assistantMessages);
+    const lastAssistantTool = detectLastAssistantToolCategory(assistantMessages);
+    const lastAssistantToolLabel = (() => {
+        if (!lastAssistantTool) {
+            return undefined;
+        }
+        if (lastAssistantTool.commandSnippet && lastAssistantTool.commandSnippet.trim()) {
+            return lastAssistantTool.commandSnippet.trim();
+        }
+        if (lastAssistantTool.name && lastAssistantTool.name.trim()) {
+            return lastAssistantTool.name.trim();
+        }
+        return undefined;
+    })();
     return {
         requestId: metadata.requestId,
         model: request.model,
         totalMessages: request.messages?.length ?? 0,
         userTextSample: latestUserText.slice(0, 2000),
-        toolCount: request.tools?.length ?? 0,
+        toolCount: meaningfulDeclaredTools.length,
         hasTools,
         hasToolCallResponses,
         hasVisionTool,
@@ -132,508 +45,12 @@ export function buildRoutingFeatures(request, metadata) {
         hasCodingTool,
         hasThinkingKeyword,
         estimatedTokens,
-        lastAssistantToolCategory: assistantToolSummary.primary?.category,
-        lastAssistantToolName: assistantToolSummary.primary?.name,
-        lastAssistantToolDetail: assistantToolSummary.primary?.detail,
-        assistantToolCategories: assistantToolSummary.categories,
-        assistantCalledWebSearchTool: assistantToolSummary.usedWebSearchTool,
+        lastAssistantToolCategory: lastAssistantTool?.category,
+        lastAssistantToolSnippet: lastAssistantTool?.commandSnippet,
+        lastAssistantToolLabel,
+        latestMessageFromUser: latestMessageRole === 'user',
         metadata: {
             ...metadata
         }
     };
 }
-function getLatestUserMessage(messages) {
-    for (let idx = messages.length - 1; idx >= 0; idx -= 1) {
-        if (messages[idx]?.role === 'user') {
-            return messages[idx];
-        }
-    }
-    return undefined;
-}
-function extractMessageText(message) {
-    if (typeof message.content === 'string' && message.content.trim()) {
-        return message.content;
-    }
-    return '';
-}
-function detectKeyword(text, keywords) {
-    if (!text)
-        return false;
-    return keywords.some((keyword) => text.includes(keyword.toLowerCase()));
-}
-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;
-}
-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 || '');
-    });
-}
-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()));
-    });
-}
-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)));
-    });
-}
-function detectExtendedThinkingKeyword(text) {
-    if (!text) {
-        return false;
-    }
-    const keywords = ['仔细分析', '思考', '超级思考', '深度思考', 'careful analysis', 'deep thinking', 'deliberate'];
-    return keywords.some((keyword) => text.includes(keyword));
-}
-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);
-}
-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 '';
-}
-function summarizeAssistantToolUsage(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;
-        }
-        const classifications = [];
-        let usedWebSearchTool = false;
-        for (const call of msg.tool_calls) {
-            const classification = classifyToolCall(call);
-            if (classification) {
-                classifications.push(classification);
-                if (classification.category === 'search' && isWebSearchToolInvocation(classification)) {
-                    usedWebSearchTool = true;
-                }
-            }
-        }
-        if (!classifications.length) {
-            continue;
-        }
-        const categorySet = new Set();
-        for (const classification of classifications) {
-            categorySet.add(classification.category);
-        }
-        const categories = orderToolCategories(Array.from(categorySet));
-        const primary = classifications.find((classification) => classification.category !== 'other') ?? classifications[0];
-        return {
-            categories,
-            primary,
-            usedWebSearchTool
-        };
-    }
-    return { categories: [], usedWebSearchTool: false };
-}
-function orderToolCategories(categories) {
-    const ordered = [];
-    for (const category of TOOL_CATEGORY_PRIORITY) {
-        if (categories.includes(category)) {
-            ordered.push(category);
-        }
-    }
-    for (const category of categories) {
-        if (!ordered.includes(category)) {
-            ordered.push(category);
-        }
-    }
-    return ordered;
-}
-function isWebSearchToolName(name) {
-    const normalized = name.toLowerCase();
-    if (SEARCH_TOOL_EXACT.has(normalized)) {
-        return true;
-    }
-    return WEB_TOOL_KEYWORDS.some((keyword) => normalized.includes(keyword.toLowerCase()));
-}
-function isWebSearchToolInvocation(classification) {
-    if (!classification) {
-        return false;
-    }
-    if (isWebSearchToolName(classification.name)) {
-        return true;
-    }
-    if (classification.detail) {
-        const detail = classification.detail.toLowerCase();
-        return WEB_TOOL_KEYWORDS.some((keyword) => detail.includes(keyword.toLowerCase()));
-    }
-    return false;
-}
-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).trim();
-    const commandDetail = summarizeCommandDetail(commandText);
-    const nameCategory = categorizeToolName(functionName);
-    if (nameCategory === 'write' || nameCategory === 'read' || nameCategory === 'search') {
-        return { category: nameCategory, name: functionName };
-    }
-    if (SHELL_TOOL_NAMES.has(functionName)) {
-        const shellCategory = classifyShellCommand(commandText);
-        return {
-            category: shellCategory,
-            name: functionName,
-            detail: commandDetail
-        };
-    }
-    if (commandText) {
-        const derivedCategory = classifyShellCommand(commandText);
-        if (derivedCategory !== 'other') {
-            return { category: derivedCategory, name: functionName };
-        }
-    }
-    return { category: 'other', name: functionName };
-}
-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)) {
-        const tokens = collectCommandTokens(args);
-        if (tokens.length) {
-            return tokens.join(' ');
-        }
-        const derived = extractFirstStringValue(args);
-        return derived ?? '';
-    }
-    if (typeof args === 'object') {
-        const record = args;
-        const command = record.command;
-        const input = record.input;
-        const nestedArgs = record.args;
-        if (typeof command === 'string') {
-            return command;
-        }
-        if (Array.isArray(command)) {
-            const tokens = collectCommandTokens(command);
-            if (tokens.length) {
-                return tokens.join(' ');
-            }
-            const derivedCommand = extractFirstStringValue(command);
-            if (derivedCommand) {
-                return derivedCommand;
-            }
-        }
-        if (command && typeof command === 'object') {
-            const derivedCommand = extractFirstStringValue(command);
-            if (derivedCommand) {
-                return derivedCommand;
-            }
-        }
-        if (typeof input === 'string') {
-            return input;
-        }
-        if (typeof nestedArgs === 'string') {
-            return nestedArgs;
-        }
-        if (Array.isArray(nestedArgs)) {
-            const tokens = collectCommandTokens(nestedArgs);
-            if (tokens.length) {
-                return tokens.join(' ');
-            }
-            const derivedArgs = extractFirstStringValue(nestedArgs);
-            if (derivedArgs) {
-                return derivedArgs;
-            }
-        }
-        if (nestedArgs && typeof nestedArgs === 'object') {
-            const derivedArgs = extractFirstStringValue(nestedArgs);
-            if (derivedArgs) {
-                return derivedArgs;
-            }
-        }
-        const fallback = extractFirstStringValue(record);
-        if (fallback) {
-            return fallback;
-        }
-        try {
-            return JSON.stringify(record);
-        }
-        catch {
-            return '';
-        }
-    }
-    return '';
-}
-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)
-        .filter(Boolean);
-    const hasWrite = segments.some((segment) => matchesAnyPattern(segment, SHELL_WRITE_PATTERNS));
-    const hasRead = segments.some((segment) => matchesAnyPattern(segment, SHELL_READ_PATTERNS));
-    if (hasWrite) {
-        return 'write';
-    }
-    if (hasRead) {
-        return 'read';
-    }
-    const hasSearch = segments.some((segment) => matchesAnyPattern(segment, SHELL_SEARCH_PATTERNS));
-    if (hasSearch) {
-        return 'search';
-    }
-    const stripped = stripShellWrapper(command);
-    if (matchesAnyPattern(stripped, SHELL_WRITE_PATTERNS)) {
-        return 'write';
-    }
-    if (matchesAnyPattern(stripped, SHELL_READ_PATTERNS)) {
-        return 'read';
-    }
-    if (matchesAnyPattern(stripped, SHELL_SEARCH_PATTERNS)) {
-        return 'search';
-    }
-    return 'other';
-}
-function splitCommandSegments(command) {
-    return command
-        .split(/(?:\r?\n|&&|\|\||;)/)
-        .map((segment) => segment.trim())
-        .filter(Boolean);
-}
-function matchesAnyPattern(text, patterns) {
-    if (!text) {
-        return false;
-    }
-    const trimmed = text.trim().toLowerCase();
-    const normalized = trimmed.startsWith('sudo ') ? trimmed.slice(5).trim() : trimmed;
-    return patterns.some((pattern) => {
-        const lowered = pattern.toLowerCase().trim();
-        return normalized.startsWith(lowered);
-    });
-}
-function stripShellWrapper(segment) {
-    let normalized = segment.trim();
-    const wrappers = ['bash -lc ', 'bash -lc', 'sh -c ', 'sh -c', '/bin/sh -c ', '/bin/sh -c', 'env -i bash -lc ', 'env -i bash -lc'];
-    for (const wrapper of wrappers) {
-        if (normalized.toLowerCase().startsWith(wrapper)) {
-            normalized = normalized.slice(wrapper.length).trim();
-            break;
-        }
-    }
-    normalized = trimEnclosingQuotes(normalized);
-    if (normalized.startsWith('sudo ')) {
-        normalized = normalized.slice(5).trim();
-    }
-    return normalized;
-}
-function trimEnclosingQuotes(value) {
-    if ((value.startsWith('"') && value.endsWith('"') && value.length > 1) ||
-        (value.startsWith("'") && value.endsWith("'") && value.length > 1)) {
-        return value.slice(1, -1).trim();
-    }
-    return value;
-}
-function summarizeCommandDetail(command) {
-    if (!command) {
-        return undefined;
-    }
-    const [firstSegment] = splitCommandSegments(command);
-    const candidate = firstSegment ?? command;
-    const normalized = candidate.replace(/\s+/g, ' ').trim();
-    if (!normalized) {
-        return undefined;
-    }
-    if (normalized.length > COMMAND_DETAIL_MAX_LENGTH) {
-        return `${normalized.slice(0, COMMAND_DETAIL_MAX_LENGTH - 1)}…`;
-    }
-    return normalized;
-}
-function collectCommandTokens(values) {
-    const tokens = [];
-    for (const value of values) {
-        if (typeof value === 'string') {
-            const trimmed = value.trim();
-            if (trimmed) {
-                tokens.push(trimmed);
-            }
-            continue;
-        }
-        if (Array.isArray(value)) {
-            const nested = collectCommandTokens(value);
-            if (nested.length) {
-                tokens.push(nested.join(' '));
-                continue;
-            }
-        }
-        if (value && typeof value === 'object') {
-            const extracted = extractFirstStringValue(value);
-            if (extracted) {
-                tokens.push(extracted.trim());
-            }
-        }
-    }
-    return tokens.filter(Boolean).slice(0, 16);
-}
-function extractFirstStringValue(value) {
-    if (!value) {
-        return undefined;
-    }
-    if (typeof value === 'string') {
-        const trimmed = value.trim();
-        return trimmed || undefined;
-    }
-    if (Array.isArray(value)) {
-        for (const item of value) {
-            const extracted = extractFirstStringValue(item);
-            if (extracted) {
-                return extracted;
-            }
-        }
-        return undefined;
-    }
-    if (typeof value === 'object') {
-        for (const candidate of Object.values(value)) {
-            const extracted = extractFirstStringValue(candidate);
-            if (extracted) {
-                return extracted;
-            }
-        }
-    }
-    return undefined;
-}

package/dist/router/virtual-router/health-manager.js

@@ -35,13 +35,8 @@ export class ProviderHealthManager {
         if (reason) {
             state.reason = reason;
         }
-        if (state.failureCount >= this.config.failureThreshold) {
-            state.state = 'tripped';
-            state.cooldownExpiresAt = Date.now() + this.config.cooldownMs;
-            if (reason) {
-                state.reason = reason;
-            }
-        }
+        // 在新版策略中，普通失败仅用于监控；不再根据 failureThreshold 自动熔断。
+        // 只有显式 fatal 或 tripProvider 调用时才会进入 tripped 状态。
         return state;
     }
     recordSuccess(providerKey) {

package/dist/router/virtual-router/message-utils.d.ts

@@ -0,0 +1,7 @@
+import type { StandardizedMessage } from '../../conversion/hub/types/standardized.js';
+export declare function getLatestUserMessage(messages: StandardizedMessage[]): StandardizedMessage | undefined;
+export declare function getLatestMessageRole(messages: StandardizedMessage[]): string | undefined;
+export declare function extractMessageText(message: StandardizedMessage): string;
+export declare function detectKeyword(text: string, keywords: string[]): boolean;
+export declare function detectExtendedThinkingKeyword(text: string): boolean;
+export declare function detectImageAttachment(message: StandardizedMessage | undefined): boolean;