@jsonstudio/llms 0.6.6 → 0.6.54

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

@@ -1,5 +1,125 @@
+import { countRequestTokens } from './token-counter.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 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 buildRoutingFeatures(request, metadata) {
     const latestUserMessage = getLatestUserMessage(request.messages);
     const assistantMessages = request.messages.filter((msg) => msg.role === 'assistant');
@@ -7,17 +127,18 @@ export function buildRoutingFeatures(request, metadata) {
     const normalizedUserText = latestUserText.toLowerCase();
     const hasTools = Array.isArray(request.tools) && request.tools.length > 0;
     const hasToolCallResponses = assistantMessages.some((msg) => Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0);
-    const estimatedTokens = estimateTokens(latestUserText, latestUserText ? 1 : 0);
+    const estimatedTokens = computeRequestTokens(request, latestUserText);
     const hasThinking = detectKeyword(normalizedUserText, THINKING_KEYWORDS);
     const hasVisionTool = detectVisionTool(request);
     const hasImageAttachment = hasVisionTool && detectImageAttachment(latestUserMessage);
     const hasCodingTool = detectCodingTool(request);
     const hasWebTool = detectWebTool(request);
     const hasThinkingKeyword = hasThinking || detectExtendedThinkingKeyword(normalizedUserText);
+    const lastAssistantTool = detectLastAssistantToolCategory(assistantMessages);
     return {
         requestId: metadata.requestId,
         model: request.model,
-        totalMessages: latestUserText ? 1 : 0,
+        totalMessages: request.messages?.length ?? 0,
         userTextSample: latestUserText.slice(0, 2000),
         toolCount: request.tools?.length ?? 0,
         hasTools,
@@ -28,6 +149,8 @@ export function buildRoutingFeatures(request, metadata) {
         hasCodingTool,
         hasThinkingKeyword,
         estimatedTokens,
+        lastAssistantToolCategory: lastAssistantTool?.category,
+        lastAssistantToolName: lastAssistantTool?.name,
         metadata: {
             ...metadata
         }
@@ -97,12 +220,15 @@ function detectCodingTool(request) {
         return false;
     }
     return request.tools.some((tool) => {
-        const functionName = extractToolName(tool);
-        const description = extractToolDescription(tool);
-        const chineseDesc = description;
-        return (/write_file|apply_patch|modify_file|edit_file|create_file|shell|terminal|bash|run_shell/i.test(functionName) ||
-            /write file|apply patch|modify file|edit file|create file|shell|terminal|bash|run shell/i.test(description || '') ||
-            /创建文件|修改文件|写入文件|执行shell|执行终端/.test(chineseDesc || ''));
+        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) {
@@ -125,12 +251,20 @@ function detectExtendedThinkingKeyword(text) {
     const keywords = ['仔细分析', '思考', '超级思考', '深度思考', 'careful analysis', 'deep thinking', 'deliberate'];
     return keywords.some((keyword) => text.includes(keyword));
 }
-function estimateTokens(text, messageCount) {
+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, messageCount * 16);
+        return Math.max(32, Math.max(messageCount, 1) * 16);
     }
     const rough = Math.ceil(text.length / 4);
-    return Math.max(rough, messageCount * 32);
+    return Math.max(rough, Math.max(messageCount, 1) * 32);
 }
 function extractToolName(tool) {
     if (!tool || typeof tool !== 'object') {
@@ -160,3 +294,198 @@ function extractToolDescription(tool) {
     }
     return '';
 }
+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);
+    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 };
+    }
+    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)) {
+        return args.map((item) => (typeof item === 'string' ? item : '')).filter(Boolean).join(' ');
+    }
+    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)) {
+            return command.map((item) => (typeof item === 'string' ? item : '')).filter(Boolean).join(' ');
+        }
+        if (typeof input === 'string') {
+            return input;
+        }
+        if (typeof nestedArgs === 'string') {
+            return nestedArgs;
+        }
+        if (Array.isArray(nestedArgs)) {
+            return nestedArgs.map((item) => (typeof item === 'string' ? item : '')).filter(Boolean).join(' ');
+        }
+    }
+    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);
+    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 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;
+}

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

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

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

@@ -0,0 +1,105 @@
+import { encoding_for_model, get_encoding } from 'tiktoken';
+const DEFAULT_ENCODING = 'cl100k_base';
+const encoderCache = new Map();
+let defaultEncoder = null;
+function getEncoder(model) {
+    if (model) {
+        const normalized = model.trim();
+        if (encoderCache.has(normalized)) {
+            return encoderCache.get(normalized);
+        }
+        try {
+            const encoder = encoding_for_model(normalized);
+            encoderCache.set(normalized, encoder);
+            return encoder;
+        }
+        catch {
+            // fall back to default encoder
+        }
+    }
+    if (!defaultEncoder) {
+        defaultEncoder = get_encoding(DEFAULT_ENCODING);
+    }
+    return defaultEncoder;
+}
+export function countRequestTokens(request) {
+    const encoder = getEncoder(request.model);
+    let total = 0;
+    for (const message of request.messages || []) {
+        total += countMessageTokens(message, encoder);
+    }
+    if (Array.isArray(request.tools)) {
+        for (const tool of request.tools) {
+            total += encodeText(JSON.stringify(tool ?? {}), encoder);
+        }
+    }
+    if (request.parameters) {
+        total += encodeText(JSON.stringify(request.parameters), encoder);
+    }
+    if (request.metadata) {
+        total += encodeText(JSON.stringify(request.metadata), encoder);
+    }
+    return total;
+}
+function countMessageTokens(message, encoder) {
+    let total = 0;
+    total += encodeText(message.role, encoder);
+    total += encodeContent(message.content, encoder);
+    if (Array.isArray(message.tool_calls)) {
+        for (const call of message.tool_calls) {
+            total += encodeText(JSON.stringify(call ?? {}), encoder);
+        }
+    }
+    if (Array.isArray(message.metadata?.toolRuns)) {
+        total += encodeText(JSON.stringify(message.metadata?.toolRuns), encoder);
+    }
+    if (message.name) {
+        total += encodeText(message.name, encoder);
+    }
+    if (message.metadata) {
+        total += encodeText(JSON.stringify(message.metadata), encoder);
+    }
+    if (message.tool_call_id) {
+        total += encodeText(message.tool_call_id, encoder);
+    }
+    return total;
+}
+function encodeContent(content, encoder) {
+    if (content === null || content === undefined) {
+        return 0;
+    }
+    if (typeof content === 'string') {
+        return encodeText(content, encoder);
+    }
+    if (Array.isArray(content)) {
+        let total = 0;
+        for (const part of content) {
+            if (typeof part === 'string') {
+                total += encodeText(part, encoder);
+            }
+            else if (part && typeof part === 'object') {
+                if (typeof part.text === 'string') {
+                    total += encodeText(part.text, encoder);
+                }
+                else {
+                    total += encodeText(JSON.stringify(part), encoder);
+                }
+            }
+        }
+        return total;
+    }
+    if (typeof content === 'object') {
+        return encodeText(JSON.stringify(content), encoder);
+    }
+    return encodeText(String(content), encoder);
+}
+function encodeText(value, encoder) {
+    if (value === null || value === undefined) {
+        return 0;
+    }
+    const text = typeof value === 'string' ? value : String(value);
+    if (!text.trim()) {
+        return 0;
+    }
+    return encoder.encode(text).length;
+}

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

@@ -111,6 +111,8 @@ export interface RoutingFeatures {
     hasCodingTool: boolean;
     hasThinkingKeyword: boolean;
     estimatedTokens: number;
+    lastAssistantToolCategory?: 'read' | 'write' | 'search' | 'other';
+    lastAssistantToolName?: string;
     metadata: RouterMetadataInput;
 }
 export interface ClassificationResult {

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

@@ -4,11 +4,11 @@
 export const DEFAULT_ROUTE = 'default';
 export const ROUTE_PRIORITY = [
     'vision',
+    'longcontext',
     'websearch',
     'coding',
-    'tools',
-    'longcontext',
     'thinking',
+    'tools',
     'background',
     DEFAULT_ROUTE
 ];

package/dist/sse/sse-to-json/builders/response-builder.js

@@ -112,6 +112,7 @@ export class ResponsesResponseBuilder {
                     this.handleOutputItemDone(event);
                     break;
                 case 'required_action':
+                case 'response.required_action':
                     this.handleRequiredAction(event);
                     break;
                 case 'response.done':

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@jsonstudio/llms",
-  "version": "0.6.006",
+  "version": "0.6.054",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
-    "build": "node scripts/bump-version.mjs && tsc -p tsconfig.json",
-    "build:dev": "node scripts/bump-version.mjs && tsc -p tsconfig.json",
+    "build": "node scripts/bump-version.mjs && tsc -p tsconfig.json && node scripts/tools/copy-compat-profiles.mjs",
+    "build:dev": "node scripts/bump-version.mjs && tsc -p tsconfig.json && node scripts/tools/copy-compat-profiles.mjs",
     "lint": "eslint --no-eslintrc -c .eslintrc.json src --ext .ts --no-cache",
     "lint:fix": "eslint --no-eslintrc -c .eslintrc.json src --ext .ts --no-cache --fix",
     "postbuild": "node scripts/tests/run-matrix-ci.mjs",